diff --git a/CONVENTIONS.md b/CONVENTIONS.md
index 05376a37..c174c7f1 100644
--- a/CONVENTIONS.md
+++ b/CONVENTIONS.md
@@ -7,21 +7,3 @@ Use async/await where possible
 Test exceptional cases first and return/throw early.
 
 Never edit files name CONVENTIONS.md or .cursorrules
-
-# Test code standards
-
-Unit test files should be in the same directory as the source file.
-
-Any usage of chai-as-promised should use async/await
-```
-it('should work well with async/await', async () => {
-    (await Promise.resolve(42)).should.equal(42)
-    await Promise.reject(new Error()).should.be.rejectedWith(Error);
-});
-```
-
-# Tool/function classes
-
-Function classes with the @funcClass(__filename) must only have the default constructor.
-
-Always use the Filesystem class in src/functions/storage/filesystem.ts to read/search/write to the local filesystem.
diff --git a/frontend/src/app/modules/agents/agent/agent-details/agent-details.component.html b/frontend/src/app/modules/agents/agent/agent-details/agent-details.component.html
index 9ef1529a..ea273789 100644
--- a/frontend/src/app/modules/agents/agent/agent-details/agent-details.component.html
+++ b/frontend/src/app/modules/agents/agent/agent-details/agent-details.component.html
@@ -1,7 +1,7 @@
 @if(agentDetails) {
     <mat-card *ngIf="agentDetails.state === 'feedback'" class="p-3 mb-4">
         <form [formGroup]="feedbackForm" (ngSubmit)="onSubmitFeedback()">
-            <mat-card-title>Feedback Requested</mat-card-title>
+            <mat-card-title class="font-bold pl-5 text-lg">Feedback Requested</mat-card-title>
             <mat-card-content style="margin-bottom: 0; margin-top: 15px">
                 <mat-expansion-panel
                         *ngIf="agentDetails.functionCallHistory && agentDetails.functionCallHistory.length > 0"
@@ -42,7 +42,7 @@
 
     <mat-card *ngIf="agentDetails?.state === 'error'" class="p-3 mb-4">
         <form [formGroup]="errorForm" (ngSubmit)="onResumeError()">
-            <mat-card-title>Agent Error</mat-card-title>
+            <mat-card-title class="font-bold pl-5 text-lg">Agent Error</mat-card-title>
             <mat-card-content style="margin-bottom: 0; margin-top: 15px">
                 <mat-expansion-panel *ngIf="agentDetails.error" style="width: 1000px; margin-bottom: 20px">
                     <mat-expansion-panel-header>
@@ -75,7 +75,7 @@
 
     <mat-card *ngIf="agentDetails?.state === 'hil'" class="p-3 mb-4">
         <form [formGroup]="hilForm" (ngSubmit)="onResumeHil()">
-            <mat-card-title>Human In Loop check</mat-card-title>
+            <mat-card-title class="font-bold pl-5 text-lg">Human In Loop check</mat-card-title>
             <mat-card-content>
                 <mat-form-field appearance="fill" class="full-width">
                     <textarea
diff --git a/frontend/src/app/modules/agents/agent/agent-details/agent-details.component.ts b/frontend/src/app/modules/agents/agent/agent-details/agent-details.component.ts
index 38543e40..73ba82d4 100644
--- a/frontend/src/app/modules/agents/agent/agent-details/agent-details.component.ts
+++ b/frontend/src/app/modules/agents/agent/agent-details/agent-details.component.ts
@@ -123,6 +123,7 @@ export class AgentDetailsComponent implements OnInit {
             })
         ).subscribe((response) => {
             if (response) {
+                this.feedbackForm.reset();
                 this.snackBar.open('Feedback submitted successfully', 'Close', { duration: 3000 });
                 this.refreshAgentDetails();
             }
@@ -289,9 +290,7 @@ export class AgentDetailsComponent implements OnInit {
         });
 
         dialogRef.afterClosed().subscribe((result) => {
-            if (result) {
-                this.resumeCompletedAgent(result.resumeInstructions);
-            }
+            if (result) this.resumeCompletedAgent(result.resumeInstructions);
         });
     }
 
diff --git a/frontend/src/app/modules/agents/agent/agent-function-calls/agent-function-calls.component.ts b/frontend/src/app/modules/agents/agent/agent-function-calls/agent-function-calls.component.ts
index f698d53a..b394ac3f 100644
--- a/frontend/src/app/modules/agents/agent/agent-function-calls/agent-function-calls.component.ts
+++ b/frontend/src/app/modules/agents/agent/agent-function-calls/agent-function-calls.component.ts
@@ -12,7 +12,20 @@ import { MatExpansionModule } from '@angular/material/expansion';
                 <div class="mb-3 font-medium text-xl">{{ invoked.function_name }}</div>
             
                 <div *ngFor="let param of invoked.parameters | keyvalue">
-                    <p><strong>{{ param.key }}:</strong> {{ param.value }}</p>
+                    <div>
+                        <strong>{{ param.key }}:</strong>
+                        <ng-container *ngIf="param.value?.toString().length <= 200">
+                            {{ param.value }}
+                        </ng-container>
+                        <mat-expansion-panel *ngIf="param.value?.toString().length > 200" class="mt-4" #expansionPanel>
+                            <mat-expansion-panel-header [class.expanded-header]="expansionPanel.expanded">
+                                <mat-panel-title class="font-normal" *ngIf="!expansionPanel.expanded">
+                                    {{ param.value?.toString().substring(0, 200) }}...
+                                </mat-panel-title>
+                            </mat-expansion-panel-header>
+                            <p>{{ param.value }}</p>
+                        </mat-expansion-panel>
+                    </div>
                 </div>
                 <mat-expansion-panel *ngIf="invoked.stdout" class="mt-4">
                     <mat-expansion-panel-header>
@@ -29,6 +42,7 @@ import { MatExpansionModule } from '@angular/material/expansion';
             </div>
         </mat-card>
     `,
+    styles: `.mat-expansion-panel-header.mat-expanded.expanded-header {  height: 1.3em; padding-top: 1.2em; }`,
     standalone: true,
     imports: [CommonModule, MatCardModule, MatExpansionModule],
 })
diff --git a/frontend/src/app/modules/agents/new-agent/new-agent.component.ts b/frontend/src/app/modules/agents/new-agent/new-agent.component.ts
index af24ecfb..847f95f6 100644
--- a/frontend/src/app/modules/agents/new-agent/new-agent.component.ts
+++ b/frontend/src/app/modules/agents/new-agent/new-agent.component.ts
@@ -177,7 +177,7 @@ export class NewAgentComponent implements OnInit {
         .subscribe({
           next: (response) => {
             this.snackBar.open('Agent started', 'Close', { duration: 3000 });
-            this.router.navigate(['/ui/agent', response.data.agentId]).catch(console.error);
+            this.router.navigate(['/ui/agents', response.data.agentId]).catch(console.error);
           },
           error: (error) => {
             this.snackBar.open(`Error ${error.message}`, 'Close', { duration: 3000 });
diff --git a/src/CONVENTIONS.md b/src/CONVENTIONS.md
new file mode 100644
index 00000000..d7436223
--- /dev/null
+++ b/src/CONVENTIONS.md
@@ -0,0 +1,19 @@
+# Backend code standards
+
+## Test code standards
+
+Unit test files should be in the same directory as the source file.
+
+Any usage of chai-as-promised should use async/await
+```
+it('should work well with async/await', async () => {
+    (await Promise.resolve(42)).should.equal(42)
+    await Promise.reject(new Error()).should.be.rejectedWith(Error);
+});
+```
+
+## Tool/function classes
+
+Function classes with the @funcClass(__filename) must only have the default constructor.
+
+Always use the Filesystem class in src/functions/storage/filesystem.ts to read/search/write to the local filesystem.
diff --git a/src/agent/cachingCodeGenAgentRunner.ts b/src/agent/cachingCodeGenAgentRunner.ts
index 5f3d77b6..3e57664d 100644
--- a/src/agent/cachingCodeGenAgentRunner.ts
+++ b/src/agent/cachingCodeGenAgentRunner.ts
@@ -259,7 +259,7 @@ export async function runCachingCodegenAgent(agent: AgentContext): Promise<Agent
 						.filter((pkg) => llmPythonCode.includes(`${pkg}.`) || pkg === 'json') // always need json for JsProxyEncoder
 						.map((pkg) => `import ${pkg}\n`)
 						.join();
-					logger.info(`Allowed imports: ${pythonScript}`);
+
 					pythonScript += `
 from typing import Any, List, Dict, Tuple, Optional, Union
 from pyodide.ffi import JsProxy
diff --git a/src/agent/codeGenAgentRunner.ts b/src/agent/codeGenAgentRunner.ts
index d088dd96..d497be52 100644
--- a/src/agent/codeGenAgentRunner.ts
+++ b/src/agent/codeGenAgentRunner.ts
@@ -3,7 +3,13 @@ import { Span, SpanStatusCode } from '@opentelemetry/api';
 import { PyodideInterface, loadPyodide } from 'pyodide';
 import { runAgentCompleteHandler } from '#agent/agentCompletion';
 import { AgentContext } from '#agent/agentContextTypes';
-import { AGENT_COMPLETED_NAME, AGENT_REQUEST_FEEDBACK, AGENT_SAVE_MEMORY_CONTENT_PARAM_NAME } from '#agent/agentFunctions';
+import {
+	AGENT_COMPLETED_NAME,
+	AGENT_COMPLETED_PARAM_NAME,
+	AGENT_REQUEST_FEEDBACK,
+	AGENT_SAVE_MEMORY_CONTENT_PARAM_NAME,
+	REQUEST_FEEDBACK_PARAM_NAME,
+} from '#agent/agentFunctions';
 import { buildFunctionCallHistoryPrompt, buildMemoryPrompt, buildToolStatePrompt, updateFunctionSchemas } from '#agent/agentPromptUtils';
 import { AgentExecution, formatFunctionError, formatFunctionResult } from '#agent/agentRunner';
 import { convertJsonToPythonDeclaration, extractPythonCode } from '#agent/codeGenAgentUtils';
@@ -215,7 +221,7 @@ export async function runCodeGenAgent(agent: AgentContext): Promise<AgentExecuti
 						.filter((pkg) => llmPythonCode.includes(`${pkg}.`) || pkg === 'json') // always need json for JsProxyEncoder
 						.map((pkg) => `import ${pkg}\n`)
 						.join();
-					logger.info(`Allowed imports: ${pythonScript}`);
+
 					pythonScript += `
 from typing import Any, List, Dict, Tuple, Optional, Union
 from pyodide.ffi import JsProxy
@@ -265,18 +271,18 @@ main()`.trim();
 
 						// Should force completed/requestFeedback to exit the script - throw a particular Error class
 						if (lastFunctionCall.function_name === AGENT_COMPLETED_NAME) {
-							logger.info('Task completed');
+							logger.info(`Task completed: ${lastFunctionCall.parameters[AGENT_COMPLETED_PARAM_NAME]}`);
 							agent.state = 'completed';
 							completed = true;
 						} else if (lastFunctionCall.function_name === AGENT_REQUEST_FEEDBACK) {
-							logger.info('Feedback requested');
+							logger.info(`Feedback requested: ${lastFunctionCall.parameters[REQUEST_FEEDBACK_PARAM_NAME]}`);
 							agent.state = 'feedback';
 							requestFeedback = true;
 						} else {
 							if (!anyFunctionCallErrors && !completed && !requestFeedback) agent.state = 'agent';
 						}
 					} catch (e) {
-						logger.info(`Caught function error ${e.message}`);
+						logger.info(e, `Caught function error ${e.message}`);
 						functionErrorCount++;
 					}
 					// Function invocations are complete
diff --git a/src/agent/forceStopAgent.ts b/src/agent/forceStopAgent.ts
new file mode 100644
index 00000000..a3336409
--- /dev/null
+++ b/src/agent/forceStopAgent.ts
@@ -0,0 +1,52 @@
+import { agentContext, agentContextStorage } from '#agent/agentContextLocalStorage';
+import { isExecuting } from '#agent/agentContextTypes';
+import { currentUser } from '#user/userService/userContext';
+import { appContext } from '../applicationContext';
+
+const agentsToStop = new Set<string>();
+
+/**
+ * Terminates the execution of an agent as soon as possible.
+ * @param agentId
+ */
+export async function forceStopAgent(agentId: string): Promise<void> {
+	const agent = await appContext().agentStateService.load(agentId);
+	if (!agent) throw new Error(`No agent with id ${agentId}`);
+	if (!isExecuting(agent)) throw new Error(`Agent ${agentId} is not in an executing state`);
+	if (agent.user.id !== currentUser().id) throw new Error('Cannot stop an agent owned by another user');
+
+	agentsToStop.add(agent.agentId);
+
+	// Reload the agent every 5 seconds for up to a minute and see if it's not in an executing state
+	return new Promise((resolve, reject) => {
+		const startTime = Date.now();
+		const interval = setInterval(async () => {
+			const updatedAgent = await appContext().agentStateService.load(agentId);
+			// Agent should be in an error state if the checkForceStopped() function has been called in its execution
+			if (!isExecuting(updatedAgent)) {
+				clearInterval(interval);
+				agentsToStop.delete(agent.agentId);
+				resolve();
+			} else if (Date.now() - startTime >= 60000) {
+				// 1 minute timeout
+				clearInterval(interval);
+				agentsToStop.delete(agent.agentId);
+				reject(new Error(`Agent ${agentId} did not stop executing within 1 minute`));
+			}
+		}, 5000);
+	});
+}
+
+/**
+ * Checks if the current agent should be force stopped
+ */
+export function checkForceStopped(): void {
+	const agent = agentContext();
+	if (!agent) return;
+	const agentId = typeof agent === 'string' ? agent : agent.agentId;
+
+	if (agentsToStop.has(agentId)) {
+		agentsToStop.delete(agentId);
+		throw new Error(`Agent ${agentId} has been force stopped by user ${currentUser().id}`);
+	}
+}
diff --git a/src/cache/cacheRetry.ts b/src/cache/cacheRetry.ts
index 79e3221c..37fa1c2a 100644
--- a/src/cache/cacheRetry.ts
+++ b/src/cache/cacheRetry.ts
@@ -40,7 +40,7 @@ export function cacheRetry(options: Partial<CacheRetryOptions> = DEFAULTS) {
 			const cacheRetryOptions = optionsWithDefaults(options);
 
 			const cacheService = appContext().functionCacheService;
-			// console.log(this.constructor.name, methodName, args)
+
 			if (cacheRetryOptions.scope) {
 				const cachedValue = await cacheService.getValue(cacheRetryOptions.scope, this.constructor.name, methodName, args);
 
@@ -51,7 +51,7 @@ export function cacheRetry(options: Partial<CacheRetryOptions> = DEFAULTS) {
 			}
 
 			for (let attempt = 1; attempt <= cacheRetryOptions.retries; attempt++) {
-				logger.debug(`${this.constructor.name}${FUNC_SEP}${methodName} retry ${attempt - 1}`);
+				if (attempt > 1) logger.debug(`${this.constructor.name}${FUNC_SEP}${methodName} retry ${attempt - 1}`);
 				try {
 					let result = originalMethod.apply(this, args);
 					if (typeof result?.then === 'function') result = await result;
diff --git a/src/cli/gaia.ts b/src/cli/gaia.ts
index 111485b6..0e72e249 100644
--- a/src/cli/gaia.ts
+++ b/src/cli/gaia.ts
@@ -11,11 +11,12 @@ import { PublicWeb } from '#functions/web/web';
 import { LlmCall } from '#llm/llmCallService/llmCall';
 import { ClaudeLLMs } from '#llm/services/anthropic';
 import { Claude3_5_Sonnet_Vertex, ClaudeVertexLLMs } from '#llm/services/anthropic-vertex';
-import { groqLlama3_1_70B } from '#llm/services/groq';
+import { groqLlama3_3_70B } from '#llm/services/groq';
 import { Gemini_1_5_Flash } from '#llm/services/vertexai';
 import { logger } from '#o11y/logger';
 import { sleep } from '#utils/async-utils';
 
+import { openAIo1 } from '#llm/services/openai';
 import { appContext, initFirestoreApplicationContext } from '../applicationContext';
 
 const SYSTEM_PROMPT = `Finish your answer with the following template: FINAL ANSWER: [YOUR FINAL ANSWER]. YOUR FINAL ANSWER should be a number OR as few words as possible OR a comma separated list of numbers and/or strings. If you are asked for a number, don't use comma to write your number neither use units such as $ or percent sign unless specified otherwise. If you are asked for a string, don't use articles, neither abbreviations (e.g. for cities), and write the digits in plain text unless specified otherwise. If you are asked for a comma separated list, apply the above rules depending of whether the element to be put in the list is a number or a string.`;
@@ -92,9 +93,9 @@ async function answerGaiaQuestion(task: GaiaQuestion): Promise<GaiaResult> {
 			// llms: ClaudeVertexLLMs(),
 			llms: {
 				easy: Gemini_1_5_Flash(),
-				medium: groqLlama3_1_70B(),
+				medium: groqLlama3_3_70B(),
 				hard: Claude3_5_Sonnet_Vertex(),
-				xhard: Claude3_5_Sonnet_Vertex(),
+				xhard: openAIo1(),
 			},
 			agentName: `gaia-${task.task_id}`,
 			type: 'codegen',
diff --git a/src/cli/gen.ts b/src/cli/gen.ts
index 6b8866ec..cee9929f 100644
--- a/src/cli/gen.ts
+++ b/src/cli/gen.ts
@@ -7,9 +7,9 @@ import { LlmFunctions } from '#agent/LlmFunctions';
 import { agentContext, agentContextStorage, createContext } from '#agent/agentContextLocalStorage';
 import { AgentContext, AgentLLMs } from '#agent/agentContextTypes';
 import { LLM } from '#llm/llm';
-import { ClaudeLLMs } from '#llm/models/anthropic';
-import { Claude3_5_Sonnet_Vertex, ClaudeVertexLLMs } from '#llm/models/anthropic-vertex';
-import { GPT4oMini } from '#llm/models/openai';
+import { ClaudeLLMs } from '#llm/services/anthropic';
+import { Claude3_5_Sonnet_Vertex, ClaudeVertexLLMs } from '#llm/services/anthropic-vertex';
+import { GPT4oMini, openAIo1 } from '#llm/services/openai';
 import { currentUser } from '#user/userService/userContext';
 import { initFirestoreApplicationContext } from '../applicationContext';
 import { CliOptions, getLastRunAgentId, parseProcessArgs, saveAgentId } from './cli';
diff --git a/src/cli/query.ts b/src/cli/query.ts
index 6a7ddce4..5bd516a6 100644
--- a/src/cli/query.ts
+++ b/src/cli/query.ts
@@ -9,7 +9,6 @@ import { ClaudeLLMs } from '#llm/services/anthropic';
 import { ClaudeVertexLLMs } from '#llm/services/anthropic-vertex';
 import { cerebrasLlama3_70b } from '#llm/services/cerebras';
 import { deepseekChat } from '#llm/services/deepseek';
-import { groqLlama3_1_70B } from '#llm/services/groq';
 import { GPT4oMini, openAIo1, openAIo1mini } from '#llm/services/openai';
 import { Gemini_1_5_Flash } from '#llm/services/vertexai';
 import { codebaseQuery } from '#swe/discovery/codebaseQuery';
diff --git a/src/cli/swebench.ts b/src/cli/swebench.ts
index bcfadce9..866d2744 100644
--- a/src/cli/swebench.ts
+++ b/src/cli/swebench.ts
@@ -14,7 +14,6 @@ import { PublicWeb } from '#functions/web/web';
 import { LlmCall } from '#llm/llmCallService/llmCall';
 import { ClaudeLLMs } from '#llm/services/anthropic';
 import { Claude3_5_Sonnet_Vertex, ClaudeVertexLLMs } from '#llm/services/anthropic-vertex';
-import { groqLlama3_1_70B } from '#llm/services/groq';
 import { Gemini_1_5_Flash } from '#llm/services/vertexai';
 import { logger } from '#o11y/logger';
 import { SWEBenchAgent, SWEInstance } from '#swe/SWEBenchAgent';
diff --git a/src/cli/watch.ts b/src/cli/watch.ts
index f43f0eab..4cad5995 100644
--- a/src/cli/watch.ts
+++ b/src/cli/watch.ts
@@ -24,14 +24,14 @@ export function startWatcher() {
 	const watcher = fs.watch(watchPath, { recursive: true }, async (event: WatchEventType, filename: string | null) => {
 		// Early exit if filename is null
 		if (!filename) return;
-		console.log(filename);
-		console.log(event);
+		console.log(`${event} ${filename}`);
+
 		const filePath = path.join(process.cwd(), watchPath, filename);
 		if (!fileExistsSync(filePath)) {
 			logger.debug(`${filePath} doesn't exist`);
 			return;
 		}
-		logger.info(`Checking ${filePath}`);
+		console.log(`Checking ${filePath}`);
 		try {
 			const data = await fs.promises.readFile(filePath, 'utf-8');
 
@@ -44,7 +44,7 @@ export function startWatcher() {
 			const lines = data.split('\n');
 
 			// Find the index of the first line that starts with '//>>' and ends with '//'
-			const index = lines.findIndex((line) => line.includes('//>>') && line.trim().endsWith('//'));
+			const index = lines.findIndex((line) => line.includes('//>') && line.trim().endsWith('//'));
 
 			// Early exit if no matching lines are found
 			if (index === -1) return;
@@ -54,7 +54,7 @@ export function startWatcher() {
 			const indentation = line.match(/^\s*/)[0]; // Capture leading whitespace for indentation
 			const requirements = line.trim().slice(3, -2).trim();
 
-			logger.info(requirements);
+			logger.info(`Extracted requirements: ${requirements}`);
 
 			// Formulate the prompt
 			const prompt = `You are to implement the TODO instructions on the line which starts with //>> and ends with //.\ni.e: ${requirements}`;
diff --git a/src/fastify/trace-init/trace-init.ts b/src/fastify/trace-init/trace-init.ts
index b58e3f04..e689098e 100644
--- a/src/fastify/trace-init/trace-init.ts
+++ b/src/fastify/trace-init/trace-init.ts
@@ -10,6 +10,7 @@ import { PinoInstrumentation } from './instrumentation';
 
 import { SemanticResourceAttributes } from '@opentelemetry/semantic-conventions';
 import { agentContextStorage } from '#agent/agentContextLocalStorage';
+import { checkForceStopped } from '#agent/forceStopAgent';
 import { setTracer } from '#o11y/trace';
 
 let initialized = false;
@@ -104,9 +105,9 @@ function initTrace(): void {
 		});
 
 		const tracer = trace.getTracer(traceServiceName);
-		setTracer(tracer, agentContextStorage);
+		setTracer(tracer, agentContextStorage, checkForceStopped);
 	} else {
-		setTracer(null, agentContextStorage);
+		setTracer(null, agentContextStorage, checkForceStopped);
 	}
 }
 
diff --git a/src/functionRegistry.ts b/src/functionRegistry.ts
index c0db83a1..6950abc5 100644
--- a/src/functionRegistry.ts
+++ b/src/functionRegistry.ts
@@ -1,4 +1,4 @@
-import { GoogleCloud } from '#functions/cloud/google-cloud';
+import { GoogleCloud } from '#functions/cloud/google/google-cloud';
 import { ImageGen } from '#functions/image';
 import { Jira } from '#functions/jira';
 import { GitHub } from '#functions/scm/github';
diff --git a/src/functions/cloud/google-cloud.ts b/src/functions/cloud/google/google-cloud.ts
similarity index 100%
rename from src/functions/cloud/google-cloud.ts
rename to src/functions/cloud/google/google-cloud.ts
diff --git a/src/functions/cloud/google/security-command-center.ts b/src/functions/cloud/google/security-command-center.ts
new file mode 100644
index 00000000..d57659bc
--- /dev/null
+++ b/src/functions/cloud/google/security-command-center.ts
@@ -0,0 +1,83 @@
+import { func, funcClass } from '#functionSchema/functionDecorators';
+import { envVar } from '#utils/env-var';
+import { execCommand, failOnError } from '#utils/exec';
+import { cacheRetry } from '../../../cache/cacheRetry';
+
+@funcClass(__filename)
+export class GoogleCloudSecurityCommandCenter {
+	/**
+	 * Gets all the active, non-muted findings for the organisation from Security Command Center
+	 * @returns the findings in JSON format as an object
+	 */
+	@func()
+	@cacheRetry({ scope: 'global' })
+	async getSecurityCommandCenterFindings(): Promise<SccFinding[]> {
+		const orgId = envVar('GCLOUD_ORGANIZATION_ID');
+
+		const result = await execCommand(`gcloud scc findings list ${orgId} -q --format=json --filter='state="ACTIVE" AND NOT mute="MUTED"'`);
+		failOnError('Error running gcloud scc findings list', result);
+		return JSON.parse(result.stdout);
+	}
+}
+
+interface FindingDetails {
+	canonicalName: string;
+	category: string;
+	createTime: string;
+	eventTime: string;
+	findingClass: string;
+	compliances: Compliance[];
+	name: string;
+	parent: string;
+	parentDisplayName: string;
+	resourceName: string;
+	securityMarks: { name: string };
+	severity: string;
+	sourceProperties: Record<string, any>;
+}
+
+interface Compliance {
+	ids: string[];
+	standard: string;
+	version: string;
+}
+
+interface Resource {
+	displayName: string;
+	location: string;
+	name: string;
+	parentDisplayName: string;
+	parentName: string;
+	projectDisplayName: string;
+	projectName: string;
+	resourcePathString: string;
+	service: string;
+	type: string;
+}
+
+export interface SccFinding {
+	finding: FindingDetails;
+	resource: Resource;
+}
+
+export type GroupedFindings = {
+	[category: string]: {
+		[projectDisplayName: string]: SccFinding[];
+	};
+};
+
+export function groupSecurityCommandCenterFindings(findings: SccFinding[]): GroupedFindings {
+	return findings.reduce((acc, finding) => {
+		const category = finding.finding.category;
+		const projectDisplayName = finding.resource.projectDisplayName || finding.finding.resourceName;
+
+		// Initialize category object and project array if it doesn't exist
+		acc[category] ??= {};
+		acc[category][projectDisplayName] ??= [];
+
+		// Add finding to the appropriate group
+		acc[category][projectDisplayName].push(finding);
+
+		return acc;
+	}, {} as GroupedFindings);
+}
diff --git a/src/functions/jira.ts b/src/functions/jira.ts
index 3d351369..5d5d7d6b 100644
--- a/src/functions/jira.ts
+++ b/src/functions/jira.ts
@@ -1,5 +1,7 @@
 import axios, { AxiosInstance } from 'axios';
+import { llms } from '#agent/agentContextLocalStorage';
 import { func, funcClass } from '#functionSchema/functionDecorators';
+import { getJiraIssueType } from '#functions/jiraIssueType';
 import { logger } from '#o11y/logger';
 import { functionConfig } from '#user/userService/userContext';
 import { envVar } from '#utils/env-var';
@@ -74,6 +76,70 @@ export class Jira {
 		}
 	}
 
+	/**
+	 * Creates a new JIRA issue
+	 * @param projectKey The Jira project key (usually a short capitalized code)
+	 * @param title The issue summary
+	 * @param description The issue description in Markdown format
+	 * @param reporterEmail The email address of the user who be assigned as the reporter for this issue.
+	 * @param relatedContentForIssueTypeDetection user content (chat messages etc) which could assist with the issue type detection
+	 * @returns {Promise<{key: string, url: string}>} The created issue key and URL
+	 */
+	@func()
+	@cacheRetry({ retries: 1, backOffMs: 1000 })
+	async createIssue(
+		projectKey: string,
+		title: string,
+		description: string,
+		reporterEmail: string,
+		relatedContentForIssueTypeDetection?: string,
+	): Promise<{ key: string; url: string }> {
+		if (!projectKey) throw new Error('projectKey is required');
+		if (!title) throw new Error('summary is required');
+		if (!description) throw new Error('description is required');
+
+		// Lookup the user id
+		const userSearchResponse = await this.axios().get('user/search', {
+			params: {
+				query: reporterEmail,
+			},
+		});
+		const users: number = userSearchResponse.data.length;
+		if (users !== 1) throw new Error(`Searching for Jira user by email ${reporterEmail} returned ${users} results, when 1 is required.`);
+		const reporterId = userSearchResponse.data[0].accountId;
+
+		// Reformat the description and lookup the issue type
+		const [issueType, formattedDescription] = await Promise.all([
+			getJiraIssueType(projectKey, title, description, relatedContentForIssueTypeDetection),
+			convertFormatting(description),
+		]);
+
+		// Create the issue
+		const response = await this.axios().post('issue', {
+			fields: {
+				project: {
+					key: projectKey,
+				},
+				summary: title,
+				description: formattedDescription,
+				issuetype: {
+					id: issueType,
+				},
+				reporter: {
+					id: reporterId,
+				},
+			},
+		});
+		logger.info(response.data);
+
+		const key = response.data.key;
+		// Create url in the format https://account.atlassian.net/browse/ABC-123
+		let url = this.instance.defaults.baseURL;
+		url = `${url.substring(0, url.indexOf('t/') + 1)}/browse/${key}`;
+
+		return { key, url };
+	}
+
 	// /**
 	//  * Search JIRA issues
 	//  * @param {string} query
@@ -91,3 +157,379 @@ export class Jira {
 	// 	}
 	// }
 }
+
+/**
+ * Converts Markdown to the Jira text formatting notation
+ * https://jira.atlassian.com/secure/WikiRendererHelpAction.jspa?section=all
+ * @param markdown
+ */
+async function convertFormatting(markdown: string): Promise<string> {
+	const prompt = `<jira-text-formatting>
+Headings
+
+To create a header, place "hn. " at the start of the line (where n can be a number from 1-6).
+
+<notation>
+h1. Biggest heading
+</notation>
+<comment>
+Biggest heading
+</comment>
+
+<notation>
+h2. Bigger heading
+</notation>
+<comment>
+Bigger heading
+</comment>
+
+<notation>
+h3. Big heading
+</notation>
+<comment>
+Big heading
+</comment>
+
+<notation>
+h4. Normal heading
+</notation>
+<comment>
+Normal heading
+</comment>
+
+<notation>
+h5. Small heading
+</notation>
+<comment>
+Small heading
+</comment>
+
+<notation>
+h6. Smallest heading
+</notation>
+<comment>
+Smallest heading
+</comment>
+
+Text Effects
+
+Text effects are used to change the formatting of words and sentences.
+
+<notation>
+*strong*
+</notation>
+<comment>
+Makes text strong.
+</comment>
+
+<notation>
+_emphasis_
+</notation>
+<comment>
+Makes text emphasis.
+</comment>
+
+<notation>
+??citation??
+</notation>
+<comment>
+Makes text in citation.
+</comment>
+
+<notation>
+-deleted-
+</notation>
+<comment>
+Makes text as deleted.
+</comment>
+
+<notation>
++inserted+
+</notation>
+<comment>
+Makes text as inserted.
+</comment>
+
+<notation>
+^superscript^
+</notation>
+<comment>
+Makes text in superscript.
+</comment>
+
+<notation>
+~subscript~
+</notation>
+<comment>
+Makes text in subscript.
+</comment>
+
+<notation>
+{}
+</notation>
+<comment>
+Makes text as monospaced.
+</comment>
+
+<notation>
+bq. Some block quoted text
+</notation>
+<comment>
+To make an entire paragraph into a block quotation, place "bq. " before it.
+</comment>
+
+<notation>
+{quote}
+here is quotable content to be quoted
+{quote}
+</notation>
+<comment>
+Quote a block of text that's longer than one paragraph.
+</comment>
+
+<notation>
+{color:red}
+look ma, red text!
+{color}
+</notation>
+<comment>
+Changes the color of a block of text.
+</comment>
+
+Text Breaks
+
+Most of the time, explicit paragraph breaks are not required - The wiki renderer will be able to paginate your paragraphs properly.
+
+<notation>
+(empty line)
+</notation>
+<comment>
+Produces a new paragraph
+</comment>
+
+<notation>
+\\\\
+</notation>
+<comment>
+Creates a line break. Not often needed, most of the time the wiki renderer will guess new lines for you appropriately.
+</comment>
+
+<notation>
+----
+</notation>
+<comment>
+Creates a horizontal ruler.
+</comment>
+
+<notation>
+---
+</notation>
+<comment>
+Produces — symbol.
+</comment>
+
+<notation>
+--
+</notation>
+<comment>
+Produces – symbol.
+</comment>
+
+Links
+
+Learning how to create links quickly is important.
+
+<notation>
+[#anchor]
+[^attachment.ext]
+</notation>
+<comment>
+Creates an internal hyperlink to the specified anchor or attachment. Appending the '#' sign followed by an anchor name will lead into a specific bookmarked point of the desired page. Having the '^' followed by the name of an attachment will lead into a link to the attachment of the current issue.
+</comment>
+
+<notation>
+[http://jira.atlassian.com]
+[Atlassian|http://atlassian.com]
+</notation>
+<comment>
+Creates a link to an external resource, special characters that come after the URL and are not part of it must be separated with a space.
+</comment>
+
+<notation>
+[mailto:legendaryservice@atlassian.com]
+</notation>
+<comment>
+Creates a link to an email address, complete with mail icon.
+</comment>
+
+<notation>
+[file:///c:/temp/foo.txt]
+[file:///z:/file/on/network/share.txt]
+</notation>
+<comment>
+Creates a download link to a file on your computer or on a network share that you have mapped to a drive.
+</comment>
+
+<notation>
+{anchor:anchorname}
+</notation>
+<comment>
+Creates a bookmark anchor inside the page.
+</comment>
+
+<notation>
+[~username]
+</notation>
+<comment>
+Creates a link to the user profile page of a particular user, with a user icon and the user's full name.
+</comment>
+
+Lists
+
+Lists allow you to present information as a series of ordered items.
+
+<notation>
+* some
+* bullet
+** indented
+** bullets
+* points
+</notation>
+<comment>
+A bulleted list (must be in first column). Use more (**) for deeper indentations.
+</comment>
+
+<notation>
+- different
+- bullet
+- types
+</notation>
+<comment>
+A list item (with -), several lines create a single list.
+</comment>
+
+<notation>
+# a
+# numbered
+# list
+</notation>
+<comment>
+A numbered list (must be in first column). Use more (##, ###) for deeper indentations.
+</comment>
+
+<notation>
+# a
+# numbered
+#* with
+#* nested
+#* bullet
+# list
+</notation>
+<comment>
+You can create mixed nested lists
+</comment>
+
+Images
+
+Images can be embedded into a wiki renderable field from attached files or remote sources.
+
+<notation>
+!http://www.host.com/image.gif!
+or
+!attached-image.gif!
+</notation>
+<comment>
+Inserts an image into the page.
+</comment>
+
+<notation>
+!image.jpg|thumbnail!
+</notation>
+<comment>
+Insert a thumbnail of the image into the page (only works with images that are attached to the page).
+</comment>
+
+<notation>
+!image.gif|align=right, vspace=4!
+</notation>
+<comment>
+For any image, you can specify attributes of the image tag as a comma separated list of name=value pairs.
+</comment>
+
+Tables
+
+Tables allow you to organise content in rows and columns, with a header row if required.
+
+<notation>
+||heading 1||heading 2||heading 3||
+|col A1|col A2|col A3|
+|col B1|col B2|col B3|
+</notation>
+<comment>
+Makes a table. Use double bars for a table heading row.
+</comment>
+
+Advanced Formatting
+
+More advanced text formatting.
+
+<notation>
+{noformat}
+preformatted piece of text so *no* further _formatting_ is done here
+{noformat}
+</notation>
+<comment>
+Makes a preformatted block of text with no syntax highlighting.
+</comment>
+
+<notation>
+{panel}
+Some text
+{panel}
+</notation>
+<comment>
+Embraces a block of text within a panel.
+</comment>
+
+<notation>
+{code:title=Bar.java|borderStyle=solid}
+// Some comments here
+public String getFoo()
+{
+    return foo;
+}
+{code}
+</notation>
+<comment>
+Makes a preformatted block of code with syntax highlighting.
+</comment>
+
+Misc
+
+Various other syntax highlighting capabilities.
+
+<notation>
+\\X
+</notation>
+<comment>
+Escape special character X (i.e. {)
+</comment>
+
+<notation>
+:) :( :P :D ;) (y) (n) (i) (/) (x) (!)
+</notation>
+<comment>
+Graphical emoticons (smileys)
+</comment>
+
+</jira-text-formatting>
+
+<description-markdown>
+${markdown}
+</description-markdown>
+
+Your task is to convert the text in the description-markdown tag from regular Markdown to the Jira text formatting.
+Output only the converted text.
+`;
+	return await llms().medium.generateText(prompt, { temperature: 0.3 });
+}
diff --git a/src/functions/jiraIssueType.ts b/src/functions/jiraIssueType.ts
new file mode 100644
index 00000000..435e95e4
--- /dev/null
+++ b/src/functions/jiraIssueType.ts
@@ -0,0 +1,35 @@
+/**
+ * Determines the issue type for a jira
+ */
+export async function getJiraIssueType(projectKey: string, title: string, description: string, relatedContentForIssueTypeDetection?: string): Promise<string> {
+	return '1';
+	// Customise this for your Jira configuration
+	// Example prompt:
+	/*
+	const prompt = `<project-key>
+${projectKey}
+</project-key>
+<title>${title}</title>
+<description>
+${description}
+</description>
+<additional-context>${relatedContentForIssueTypeDetection ?? ''}</additional-context>
+
+<issue-selection-instructions>
+If the issue is about feature requests and the project key is ABC then the issue type is 6.
+If the issue is a bug fix and the project key is ABC then the issue type is 7.
+</issue-selection-instructions>
+
+Explain your thought process selecting the appropriate issue type, then finally respond with the issue type in <result> tags.
+
+Example response format:
+
+<thoughts>
+- The description describes a feature request and the project key is "ABC" which indicates the issue type should be 6.
+</thoughts>
+<result>
+6
+</result>`;
+	return await llms().medium.generateTextWithResult(prompt);
+	*/
+}
diff --git a/src/functions/storage/fileSystemService.ts b/src/functions/storage/fileSystemService.ts
index 69e1c650..bd4ffffd 100644
--- a/src/functions/storage/fileSystemService.ts
+++ b/src/functions/storage/fileSystemService.ts
@@ -270,15 +270,20 @@ export class FileSystemService {
 	 * @returns the contents of the file(s) in format <file_contents path="dir/file1">file1 contents</file_contents><file_contents path="dir/file2">file2 contents</file_contents>
 	 */
 	async readFile(filePath: string): Promise<string> {
+		// Want to check that the activeSpan is FileSystemRead.readFile, otherwise don't add to the span attributes
+		// const span = getActiveSpan();
+		// span.setAttribute('argPath', filePath)
 		logger.debug(`readFile ${filePath}`);
 		let contents: string;
 		const relativeFullPath = path.join(this.getWorkingDirectory(), filePath);
 		logger.debug(`Checking ${filePath} and ${relativeFullPath}`);
 		// Check relative to current working directory first
 		if (existsSync(relativeFullPath)) {
+			// span.setAttribute('resolvedPath', relativeFullPath)
 			contents = (await fs.readFile(relativeFullPath)).toString();
 			// Then check if it's an absolute path
 		} else if (filePath.startsWith('/') && existsSync(filePath)) {
+			// span.setAttribute('resolvedPath', filePath)
 			contents = (await fs.readFile(filePath)).toString();
 		} else {
 			throw new Error(`File ${filePath} does not exist`);
diff --git a/src/llm/base-llm.test.ts b/src/llm/base-llm.test.ts
new file mode 100644
index 00000000..47f75547
--- /dev/null
+++ b/src/llm/base-llm.test.ts
@@ -0,0 +1,106 @@
+import { expect } from 'chai';
+import { LlmMessage } from '#llm/llm';
+import { BaseLLM } from './base-llm';
+
+// Create a concrete subclass of BaseLLM for testing
+class TestLLM extends BaseLLM {
+	constructor() {
+		super(
+			'Test LLM',
+			'test-service',
+			'test-model',
+			1000,
+			() => 0,
+			() => 0,
+		);
+	}
+
+	// Expose the protected method for testing
+	public parseParameters(userOrSystemOrMessages: string | LlmMessage[], userOrOptions?: string | any, opts?: any) {
+		return this.parseGenerateTextParameters(userOrSystemOrMessages, userOrOptions, opts);
+	}
+}
+
+describe.only('BaseLLM.parseGenerateTextParameters', () => {
+	const testLLM = new TestLLM();
+
+	it('should handle userPrompt and opts', () => {
+		const userPrompt = 'Hello, how are you?';
+		const options = { temperature: 0.7 };
+		const result = testLLM.parseParameters(userPrompt, options);
+
+		expect(result.messages).to.deep.equal([{ role: 'user', content: userPrompt }]);
+		expect(result.options).to.deep.equal(options);
+	});
+
+	it('should handle systemPrompt, userPrompt, and opts', () => {
+		const systemPrompt = 'You are a helpful assistant.';
+		const userPrompt = 'Tell me a joke.';
+		const options = { temperature: 0.5 };
+		const result = testLLM.parseParameters(systemPrompt, userPrompt, options);
+
+		expect(result.messages).to.deep.equal([
+			{ role: 'system', content: systemPrompt },
+			{ role: 'user', content: userPrompt },
+		]);
+		expect(result.options).to.equal(options);
+	});
+
+	it('should handle messages array and opts', () => {
+		const messages: LlmMessage[] = [
+			{ role: 'system', content: 'You are a calculator.' },
+			{ role: 'user', content: 'What is 2 + 2?' },
+		];
+		const options = { temperature: 0 };
+		const result = testLLM.parseParameters(messages, options);
+
+		expect(result.messages).to.deep.equal(messages);
+		expect(result.options).to.equal(options);
+	});
+
+	it('should handle only userPrompt', () => {
+		const userPrompt = 'What is the weather today?';
+		const result = testLLM.parseParameters(userPrompt);
+
+		expect(result.messages).to.deep.equal([{ role: 'user', content: userPrompt }]);
+		expect(result.options).to.be.undefined;
+	});
+
+	it('should handle messages array without options', () => {
+		const messages: LlmMessage[] = [
+			{ role: 'user', content: 'Hi there!' },
+			{ role: 'assistant', content: 'Hello!' },
+		];
+		const result = testLLM.parseParameters(messages);
+		expect(result.messages).to.deep.equal(messages);
+		expect(result.options).to.be.undefined;
+	});
+
+	describe.skip('Additional test cases for edge cases and invalid inputs', () => {
+		// AI generated, need to be fixed
+		it('should throw an error when userPrompt is undefined', () => {
+			const userPrompt = undefined;
+			expect(() => testLLM.parseParameters(userPrompt as any)).to.throw(Error);
+		});
+
+		it('should throw an error when userPrompt is empty', () => {
+			const userPrompt = '';
+			expect(() => testLLM.parseParameters(userPrompt as any)).to.throw(Error);
+		});
+
+		it('should throw an error when no prompts are provided', () => {
+			const options = { temperature: 0.7 };
+			expect(() => testLLM.parseParameters(undefined as any, options)).to.throw(Error);
+		});
+
+		it('should throw an error for invalid message role', () => {
+			const messages: LlmMessage[] = [{ role: 'invalid_role' as any, content: 'This role is invalid.' }];
+			expect(() => testLLM.parseParameters(messages)).to.throw(Error);
+		});
+
+		it('should throw an error when arguments have incorrect types', () => {
+			const userPrompt = 12345; // Incorrect type
+			expect(() => testLLM.parseParameters(userPrompt as any)).to.throw(Error);
+		});
+	});
+});
diff --git a/src/llm/llm.ts b/src/llm/llm.ts
index 8a127bc5..0a4c05d9 100644
--- a/src/llm/llm.ts
+++ b/src/llm/llm.ts
@@ -87,9 +87,9 @@ export interface LLM {
 	 * This allows the LLM to generate reasoning etc before the JSON object. However, it's not possible to use structured outputs
 	 * which restrict the response to a schema.
 	 */
-	generateTextWithJson(userPrompt: string, opts?: GenerateTextOptions): Promise<string>;
-	generateTextWithJson(systemPrompt: string, userPrompt: string, opts?: GenerateTextOptions): Promise<string>;
-	generateTextWithJson(messages: LlmMessage[], opts?: GenerateTextOptions): Promise<string>;
+	generateTextWithJson<T>(userPrompt: string, opts?: GenerateJsonOptions): Promise<T>;
+	generateTextWithJson<T>(systemPrompt: string, userPrompt: string, opts?: GenerateJsonOptions): Promise<T>;
+	generateTextWithJson<T>(messages: LlmMessage[], opts?: GenerateJsonOptions): Promise<T>;
 
 	/** Generates a response which only returns a JSON object. */
 	generateJson<T>(userPrompt: string, opts?: GenerateJsonOptions): Promise<T>;
diff --git a/src/llm/services/groq.ts b/src/llm/services/groq.ts
index e88fe496..7f584232 100644
--- a/src/llm/services/groq.ts
+++ b/src/llm/services/groq.ts
@@ -3,7 +3,6 @@ import Groq from 'groq-sdk';
 import { agentContext } from '#agent/agentContextLocalStorage';
 import { addCost } from '#agent/agentContextLocalStorage';
 import { LlmCall } from '#llm/llmCallService/llmCall';
-import { AiLLM } from '#llm/services/ai-llm';
 import { withActiveSpan } from '#o11y/trace';
 import { currentUser } from '#user/userService/userContext';
 import { envVar } from '#utils/env-var';
@@ -16,39 +15,19 @@ export const GROQ_SERVICE = 'groq';
 
 export function groqLLMRegistry(): Record<string, () => LLM> {
 	return {
-		'groq:gemma2-9b-it': groqGemma2_9b,
-		'groq:llama-3.1-8b-instant': groqLlama3_1_8b,
-		'groq:llama-3.1-70b-versatile': groqLlama3_1_70B,
+		'groq:llama-3.3-70b-versatile': groqLlama3_3_70B,
 	};
 }
 
-export function groqGemma2_9b(): LLM {
-	return new GroqLLM(
-		'Gemma2 9b-it (Groq)',
-		GROQ_SERVICE,
-		'gemma2-9b-it',
-		8_192,
-		(input: string) => (input.length * 0.2) / (1_000_000 * 3.5),
-		(output: string) => (output.length * 0.2) / (1_000_000 * 3.5),
-	);
-}
-
-export function groqLlama3_1_8b(): LLM {
-	return new GroqLLM(
-		'LLaMA3.1 8b (Groq)',
-		GROQ_SERVICE,
-		'llama-3.1-8b-instant',
-		131_072,
-		(input: string) => (input.length * 0.05) / (1_000_000 * 4),
-		(output: string) => (output.length * 0.08) / (1_000_000 * 4),
-	);
-}
+// Pricing and model ids at
+// https://groq.com/pricing/
+// https://console.groq.com/docs/models
 
-export function groqLlama3_1_70B(): LLM {
+export function groqLlama3_3_70B(): LLM {
 	return new GroqLLM(
-		'Llama3.1 70b (Groq)',
+		'Llama3.3 70b (Groq)',
 		GROQ_SERVICE,
-		'llama-3.1-70b-versatile',
+		'llama-3.3-70b-versatile',
 		131_072,
 		(input: string) => (input.length * 0.59) / (1_000_000 * 4),
 		(output: string) => (output.length * 0.79) / (1_000_000 * 4),
diff --git a/src/llm/services/llm.int.ts b/src/llm/services/llm.int.ts
index 71bff71b..0a19b364 100644
--- a/src/llm/services/llm.int.ts
+++ b/src/llm/services/llm.int.ts
@@ -6,7 +6,7 @@ import { cerebrasLlama3_8b } from '#llm/services/cerebras';
 import { deepinfraQwQ_32B, deepinfraQwen2_5_Coder32B } from '#llm/services/deepinfra';
 import { deepseekChat } from '#llm/services/deepseek';
 import { fireworksLlama3_70B } from '#llm/services/fireworks';
-import { groqLlama3_1_8b } from '#llm/services/groq';
+import { groqLlama3_3_70B } from '#llm/services/groq';
 import { Ollama_Phi3 } from '#llm/services/ollama';
 import { GPT4oMini } from '#llm/services/openai';
 import { togetherLlama3_70B } from '#llm/services/together';
@@ -99,7 +99,7 @@ describe('LLMs', () => {
 		});
 
 		describe('Groq', () => {
-			const llm = groqLlama3_1_8b();
+			const llm = groqLlama3_3_70B();
 
 			it('should generateText', async () => {
 				const response = await llm.generateText(SKY_PROMPT, { temperature: 0 });
diff --git a/src/llm/services/vertexai.ts b/src/llm/services/vertexai.ts
index 2fd4017c..55a33f15 100644
--- a/src/llm/services/vertexai.ts
+++ b/src/llm/services/vertexai.ts
@@ -15,12 +15,12 @@ import { GenerateTextOptions, LLM, combinePrompts } from '../llm';
 import { MultiLLM } from '../multi-llm';
 
 export function GEMINI_1_5_PRO_LLMS(): AgentLLMs {
-	const pro1_5 = Gemini_1_5_Pro();
+	const flash2 = Gemini_2_0_Flash();
 	return {
-		easy: Gemini_1_5_Flash(),
-		medium: pro1_5,
-		hard: pro1_5,
-		xhard: new MultiLLM([pro1_5], 5),
+		easy: flash2,
+		medium: flash2,
+		hard: flash2,
+		xhard: new MultiLLM([flash2], 5),
 	};
 }
 
@@ -28,9 +28,9 @@ export const VERTEX_SERVICE = 'vertex';
 
 export function vertexLLMRegistry(): Record<string, () => LLM> {
 	return {
-		[`${VERTEX_SERVICE}:gemini-experimental`]: Gemini_1_5_Experimental,
 		[`${VERTEX_SERVICE}:gemini-1.5-pro`]: Gemini_1_5_Pro,
 		[`${VERTEX_SERVICE}:gemini-1.5-flash`]: Gemini_1_5_Flash,
+		[`${VERTEX_SERVICE}:gemini-2.0-flash`]: Gemini_2_0_Flash,
 		[`${VERTEX_SERVICE}:Llama3-405b-instruct-maas`]: Vertex_Llama3_405b,
 	};
 }
@@ -76,6 +76,17 @@ export function Gemini_1_5_Flash() {
 	);
 }
 
+export function Gemini_2_0_Flash() {
+	return new VertexLLM(
+		'Gemini 2.0 Flash Experimental',
+		VERTEX_SERVICE,
+		'gemini-2.0-flash-exp',
+		1_000_000,
+		(input: string) => 0, //(input.length * 0.000125) / 1000,
+		(output: string) => 0, //(output.length * 0.000375) / 1000,
+	);
+}
+
 // async imageToText(urlOrBytes: string | Buffer): Promise<string> {
 //   return withActiveSpan('imageToText', async (span) => {
 //     const generativeVisionModel = this.vertex().getGenerativeModel({
diff --git a/src/modules/slack/slackChatBotService.ts b/src/modules/slack/slackChatBotService.ts
index 300f18b4..5b2224a9 100644
--- a/src/modules/slack/slackChatBotService.ts
+++ b/src/modules/slack/slackChatBotService.ts
@@ -4,7 +4,7 @@ import { getLastFunctionCallArg } from '#agent/agentCompletion';
 import { AgentCompleted, AgentContext, isExecuting } from '#agent/agentContextTypes';
 import { AGENT_COMPLETED_PARAM_NAME, REQUEST_FEEDBACK_PARAM_NAME } from '#agent/agentFunctions';
 import { resumeCompleted, startAgent } from '#agent/agentRunner';
-import { GoogleCloud } from '#functions/cloud/google-cloud';
+import { GoogleCloud } from '#functions/cloud/google/google-cloud';
 import { GitLab } from '#functions/scm/gitlab';
 import { LlmTools } from '#functions/util';
 import { Perplexity } from '#functions/web/perplexity';
diff --git a/src/o11y/trace.ts b/src/o11y/trace.ts
index fc104e36..b46da147 100644
--- a/src/o11y/trace.ts
+++ b/src/o11y/trace.ts
@@ -27,15 +27,18 @@ const dummyTracer = {
 
 let tracer: SugaredTracer | null = null;
 let agentContextStorage: AsyncLocalStorage<AgentContext>;
+let checkForceStopped: () => void;
 
 /**
  * @param {Tracer} theTracer - Tracer to be set by the trace-init service
  * @param theAgentContextStorage
+ * @param checkForcedStoppedFunc
  */
-export function setTracer(theTracer: Tracer, theAgentContextStorage: AsyncLocalStorage<AgentContext>): void {
+export function setTracer(theTracer: Tracer, theAgentContextStorage: AsyncLocalStorage<AgentContext>, checkForcedStoppedFunc: () => void = () => {}): void {
 	if (theTracer) tracer = wrapTracer(theTracer);
-	// Having the agentContextStorage() function call in this file was causing a compile failure, so we need to pass in the reference to the storage.
+	// Having the agentContextStorage() and checkForcedStopped () function call in this file causes a compile failure, so we need to pass in the reference to the storage.
 	agentContextStorage = theAgentContextStorage;
+	checkForceStopped = checkForcedStoppedFunc;
 }
 
 export function getTracer(): SugaredTracer | null {
@@ -50,6 +53,7 @@ export function getTracer(): SugaredTracer | null {
  * @returns a new span
  */
 export function startSpan(spanName: string): Span {
+	checkForceStopped();
 	return tracer?.startSpan(spanName) ?? <Span>(<unknown>dummyTracer.startSpan());
 }
 
@@ -66,6 +70,7 @@ export function getActiveSpan(): Span | null {
  */
 export async function withActiveSpan<T>(spanName: string, func: (span: Span) => T): Promise<T> {
 	if (!spanName) console.error(new Error(), 'spanName not provided');
+	checkForceStopped();
 	const functionWithCallStack = async (span: Span): Promise<T> => {
 		try {
 			agentContextStorage?.getStore()?.callStack?.push(spanName);
@@ -85,6 +90,7 @@ export async function withActiveSpan<T>(spanName: string, func: (span: Span) =>
  * @param func
  */
 export function withSpan<T>(spanName: string, func: (span: Span) => T): T {
+	checkForceStopped();
 	if (!tracer) return func(fakeSpan);
 
 	return tracer.withSpan(spanName, func);
@@ -111,6 +117,7 @@ export function span(attributeExtractors: SpanAttributeExtractors = {}) {
 	return function spanDecorator(originalMethod: any, context: ClassMethodDecoratorContext): any {
 		const functionName = String(context.name);
 		return async function replacementMethod(this: any, ...args: any[]) {
+			checkForceStopped();
 			try {
 				agentContextStorage?.getStore()?.callStack?.push(functionName);
 				if (!tracer) {
diff --git a/src/routes/agent/agent-execution-routes.ts b/src/routes/agent/agent-execution-routes.ts
index 3b614bda..7448c3fa 100644
--- a/src/routes/agent/agent-execution-routes.ts
+++ b/src/routes/agent/agent-execution-routes.ts
@@ -2,6 +2,7 @@ import { Type } from '@sinclair/typebox';
 import { LlmFunctions } from '#agent/LlmFunctions';
 import { AgentContext } from '#agent/agentContextTypes';
 import { cancelAgent, provideFeedback, resumeCompleted, resumeError, resumeHil } from '#agent/agentRunner';
+import { forceStopAgent } from '#agent/forceStopAgent';
 import { runXmlAgent } from '#agent/xmlAgentRunner';
 import { send, sendBadRequest } from '#fastify/index';
 import { functionFactory } from '#functionSchema/functionDecorators';
@@ -11,6 +12,25 @@ import { AppFastifyInstance } from '../../server';
 
 const v1BasePath = '/api/agent/v1';
 export async function agentExecutionRoutes(fastify: AppFastifyInstance) {
+	/** Forcibly stop an agent */
+	fastify.post(
+		`${v1BasePath}/force-stop`,
+		{
+			schema: {
+				body: Type.Object({
+					agentId: Type.String(),
+				}),
+			},
+		},
+		async (req, reply) => {
+			const { agentId } = req.body;
+
+			await forceStopAgent(agentId);
+
+			send(reply, 200);
+		},
+	);
+
 	/** Provides feedback to an agent */
 	fastify.post(
 		`${v1BasePath}/feedback`,
diff --git a/src/swe/documentationBuilder.ts b/src/swe/documentationBuilder.ts
index f07096b7..591939b4 100644
--- a/src/swe/documentationBuilder.ts
+++ b/src/swe/documentationBuilder.ts
@@ -1,7 +1,9 @@
 import { promises as fs } from 'node:fs';
 import { basename, dirname, join } from 'path';
+import { Span } from '@opentelemetry/api';
 import { getFileSystem, llms } from '#agent/agentContextLocalStorage';
 import { logger } from '#o11y/logger';
+import { getActiveSpan, withActiveSpan } from '#o11y/trace';
 import { sleep } from '#utils/async-utils';
 import { errorToString } from '#utils/errors';
 import { sophiaDirName } from '../appVars';
@@ -36,12 +38,21 @@ export async function buildSummaryDocs(
 	fileFilter: (path: string) => boolean = (file) => (file.endsWith('.tf') || file.endsWith('.ts') || file.endsWith('.py')) && !file.endsWith('test.ts'),
 ): Promise<void> {
 	logger.info('Building summary docs');
-	// In the first pass we generate the summaries for the individual files
-	await buildFileDocs(fileFilter);
-	// // In the second pass we build the folder-level summaries from the bottom up
-	await buildFolderDocs();
-	// Generate a project-level summary from the folder summaries
-	await generateTopLevelSummary();
+
+	await withActiveSpan('buildSummaryDocs', async (span: Span) => {
+		await withActiveSpan('buildFileDocs', async (span: Span) => {
+			// In the first pass we generate the summaries for the individual files
+			await buildFileDocs(fileFilter);
+		});
+		await withActiveSpan('buildFolderDocs', async (span: Span) => {
+			// In the second pass we build the folder-level summaries from the bottom up
+			await buildFolderDocs();
+		});
+		await withActiveSpan('generateTopLevelSummary', async (span: Span) => {
+			// Generate a project-level summary from the folder summaries
+			await generateTopLevelSummary();
+		});
+	});
 }
 
 // Utils -----------------------------------------------------------
@@ -111,7 +122,18 @@ The summaries should be in a very terse, gramatically shortened writing style th
 
 Note: Avoid duplicating information from parent summaries. Focus on what's unique to this file.
 
+Provide terse values for short and long values, in a similar style to the example.
+
+Respond with the questions and then JSON in this format:
+<json>
+{
+  "short": "Key details",
+  "long": "Extended details. Key points. Identifiers"
+}
+</json>
+
 <example>
+<example-request>
 When the filename is variables.tf or output.tf and just has variable declarations respond like the following. Variables which are common to all (ie. project_id, project_number, region) dont require any description.
 <file_contents>
 variable "project_id" {
@@ -129,17 +151,23 @@ variable "run_sa" {
   type        = string
 }
 </file_contents>
-<response>
+</example-request>
+<example-response>
+# Possible questions:
+- What services are regional?
+- What service accounts are used by Cloud Runs?
+
 <json>
 {
   "short": "project_id, region, run_sa",
   "long": "project_id, region, run_sa: Cloud Run Service Account",
 }
 </json>
-</response>
+</example-response>
 </example>
 
 <example>
+<example-request>
 When a file has terraform resources respond like this example.
 <file_contents>
 terraform {
@@ -152,8 +180,8 @@ terraform {
   }
 }
 
-resource "google_cloud_run_service" "affiliate-conversion-importer" {
-  name     = "affiliate-conversion-importer"
+resource "google_cloud_run_service" "foo-service" {
+  name     = "foo-service"
   location = var.region
   project  = var.project_id
 
@@ -173,25 +201,26 @@ resource "google_cloud_run_service" "affiliate-conversion-importer" {
   }
 }
 </file_contents>
-<response>
+</example-request>
+
+<example-response>
+# Possible questions:
+- What services are regional?
+- Why isn't the foo-service changing when the template is updated?
+
 <json>
 {
-    "short": "Cloud run service affiliate-conversion-importer",
-    "long": "Cloud run service affiliate-conversion-importer with region, project_id, run_sa vars. Ignores changes to template."
+    "short": "Cloud run service foo-service",
+    "long": "Cloud run service foo-service with region, project_id, run_sa vars. Ignores changes to template."
 }
 </json>
-</response>
+</example-response>
 </example>
-Note the terse values for short and long in the previous example.
-
-Respond with JSON in this format:
-{
-  "short": "Key details",
-  "long": "Extended details. Key points. Identifiers"
-}`;
+`;
 
 			logger.info(`Generating summary for ${file}`);
-			const doc = (await easyLlm.generateJson(prompt)) as Summary;
+			// TODO batch these in parallel
+			const doc = (await easyLlm.generateJson(prompt, { id: 'Generate file summary' })) as Summary;
 			doc.path = file;
 			logger.info(doc);
 			// Save the documentation summary files in a parallel directory structure under the .sophia/docs folder
@@ -236,6 +265,7 @@ export async function buildFolderDocs(): Promise<void> {
 	const sortedFolders = sortFoldersByDepth(folders);
 
 	for (const folderPath of sortedFolders) {
+		// TODO batch these in parallel, make sure the ordering is ok
 		let filesAndSubFoldersCombinedSummary: string;
 		try {
 			const fileSummaries: Summary[] = await getFileSummaries(folderPath);
@@ -355,7 +385,7 @@ Task: Generate a cohesive summary for this folder that captures its role in the
 
 Note: Focus on the folder's unique contributions. Avoid repeating information from parent summaries.
 
-Respond with JSON in this format:
+Respond only with JSON in this format:
 <json>
 {
   "sentence": "Concise one-sentence folder summary",
@@ -364,7 +394,7 @@ Respond with JSON in this format:
 </json>
 `;
 
-	return await llm.generateJson(prompt);
+	return await llm.generateJson(prompt, { id: 'Generate folder summary' });
 }
 
 /**
@@ -394,7 +424,7 @@ export async function generateTopLevelSummary(): Promise<string> {
 	const combinedSummary = folderSummaries.map((summary) => `${summary.path}:\n${summary.long}`).join('\n\n');
 
 	// Generate the top-level summary using LLM
-	const topLevelSummary = await llms().easy.generateText(generateDetailedSummaryPrompt(combinedSummary));
+	const topLevelSummary = await llms().easy.generateText(generateDetailedSummaryPrompt(combinedSummary), { id: 'Generate top level summary' });
 
 	// Save the top-level summary
 	await saveTopLevelSummary(cwd, topLevelSummary);