Roo to main

packages/types/npm/package.metadata.json

@@ -1,6 +1,6 @@
 {
 	"name": "@roo-code/types",
-	"version": "1.90.0",
+	"version": "1.91.0",
 	"description": "TypeScript type definitions for Roo Code.",
 	"publishConfig": {
 		"access": "public",

packages/types/src/__tests__/cloud.test.ts

@@ -1,10 +1,13 @@
 // npx vitest run src/__tests__/cloud.test.ts
 
 import {
+	organizationCloudSettingsSchema,
 	organizationFeaturesSchema,
 	organizationSettingsSchema,
+	type OrganizationCloudSettings,
 	type OrganizationFeatures,
 	type OrganizationSettings,
+	type WorkspaceTaskVisibility,
 } from "../cloud.js"
 
 describe("organizationFeaturesSchema", () => {
@@ -171,3 +174,84 @@ describe("organizationSettingsSchema with features", () => {
 		expect(result.data).toEqual(input)
 	})
 })
+
+describe("organizationCloudSettingsSchema with workspaceTaskVisibility", () => {
+	it("should validate without workspaceTaskVisibility property", () => {
+		const input = {
+			recordTaskMessages: true,
+			enableTaskSharing: true,
+		}
+		const result = organizationCloudSettingsSchema.safeParse(input)
+		expect(result.success).toBe(true)
+		expect(result.data?.workspaceTaskVisibility).toBeUndefined()
+	})
+
+	it("should validate with workspaceTaskVisibility as 'all'", () => {
+		const input = {
+			recordTaskMessages: true,
+			workspaceTaskVisibility: "all" as WorkspaceTaskVisibility,
+		}
+		const result = organizationCloudSettingsSchema.safeParse(input)
+		expect(result.success).toBe(true)
+		expect(result.data?.workspaceTaskVisibility).toBe("all")
+	})
+
+	it("should validate with workspaceTaskVisibility as 'list-only'", () => {
+		const input = {
+			workspaceTaskVisibility: "list-only" as WorkspaceTaskVisibility,
+		}
+		const result = organizationCloudSettingsSchema.safeParse(input)
+		expect(result.success).toBe(true)
+		expect(result.data?.workspaceTaskVisibility).toBe("list-only")
+	})
+
+	it("should validate with workspaceTaskVisibility as 'full-lockdown'", () => {
+		const input = {
+			workspaceTaskVisibility: "full-lockdown" as WorkspaceTaskVisibility,
+		}
+		const result = organizationCloudSettingsSchema.safeParse(input)
+		expect(result.success).toBe(true)
+		expect(result.data?.workspaceTaskVisibility).toBe("full-lockdown")
+	})
+
+	it("should reject invalid workspaceTaskVisibility value", () => {
+		const input = {
+			workspaceTaskVisibility: "invalid-value",
+		}
+		const result = organizationCloudSettingsSchema.safeParse(input)
+		expect(result.success).toBe(false)
+	})
+
+	it("should have correct TypeScript type", () => {
+		// Type-only test to ensure TypeScript compilation
+		const settings: OrganizationCloudSettings = {
+			recordTaskMessages: true,
+			workspaceTaskVisibility: "all",
+		}
+		expect(settings.workspaceTaskVisibility).toBe("all")
+
+		const settingsWithoutVisibility: OrganizationCloudSettings = {
+			recordTaskMessages: false,
+		}
+		expect(settingsWithoutVisibility.workspaceTaskVisibility).toBeUndefined()
+	})
+
+	it("should validate in organizationSettingsSchema with workspaceTaskVisibility", () => {
+		const input = {
+			version: 1,
+			cloudSettings: {
+				recordTaskMessages: true,
+				enableTaskSharing: true,
+				workspaceTaskVisibility: "list-only" as WorkspaceTaskVisibility,
+			},
+			defaultSettings: {},
+			allowList: {
+				allowAll: true,
+				providers: {},
+			},
+		}
+		const result = organizationSettingsSchema.safeParse(input)
+		expect(result.success).toBe(true)
+		expect(result.data?.cloudSettings?.workspaceTaskVisibility).toBe("list-only")
+	})
+})

packages/types/src/cloud.ts

@@ -120,6 +120,14 @@ export const organizationDefaultSettingsSchema = globalSettingsSchema
 
 export type OrganizationDefaultSettings = z.infer<typeof organizationDefaultSettingsSchema>
 
+/**
+ * WorkspaceTaskVisibility
+ */
+
+const workspaceTaskVisibilitySchema = z.enum(["all", "list-only", "full-lockdown"])
+
+export type WorkspaceTaskVisibility = z.infer<typeof workspaceTaskVisibilitySchema>
+
 /**
  * OrganizationCloudSettings
  */
@@ -129,6 +137,7 @@ export const organizationCloudSettingsSchema = z.object({
 	enableTaskSharing: z.boolean().optional(),
 	taskShareExpirationDays: z.number().int().positive().optional(),
 	allowMembersViewAllTasks: z.boolean().optional(),
+	workspaceTaskVisibility: workspaceTaskVisibilitySchema.optional(),
 })
 
 export type OrganizationCloudSettings = z.infer<typeof organizationCloudSettingsSchema>

src/api/providers/openrouter.ts

@@ -44,6 +44,13 @@ type OpenRouterChatCompletionParams = OpenAI.Chat.ChatCompletionCreateParams & {
 	reasoning?: OpenRouterReasoningParams
 }
 
+// OpenRouter error structure that may include metadata.raw with actual upstream error
+interface OpenRouterErrorResponse {
+	message?: string
+	code?: number
+	metadata?: { raw?: string }
+}
+
 // See `OpenAI.Chat.Completions.ChatCompletionChunk["usage"]`
 // `CompletionsAPI.CompletionUsage`
 // See also: https://openrouter.ai/docs/use-cases/usage-accounting
@@ -111,6 +118,29 @@ export class OpenRouterHandler extends BaseProvider implements SingleCompletionH
 		return this.currentReasoningDetails.length > 0 ? this.currentReasoningDetails : undefined
 	}
 
+	/**
+	 * Handle OpenRouter streaming error response and report to telemetry.
+	 * OpenRouter may include metadata.raw with the actual upstream provider error.
+	 */
+	private handleStreamingError(error: OpenRouterErrorResponse, modelId: string, operation: string): never {
+		const rawErrorMessage = error?.metadata?.raw || error?.message
+
+		const apiError = Object.assign(
+			new ApiProviderError(
+				rawErrorMessage ?? "Unknown error",
+				this.providerName,
+				modelId,
+				operation,
+				error?.code,
+			),
+			{ status: error?.code, error: { message: error?.message, metadata: error?.metadata } },
+		)
+
+		TelemetryService.instance.captureException(apiError)
+
+		throw new Error(`OpenRouter API Error ${error?.code}: ${rawErrorMessage}`)
+	}
+
 	override async *createMessage(
 		systemPrompt: string,
 		messages: Anthropic.Messages.MessageParam[],
@@ -228,15 +258,9 @@ export class OpenRouterHandler extends BaseProvider implements SingleCompletionH
 		try {
 			stream = await this.client.chat.completions.create(completionParams, requestOptions)
 		} catch (error) {
-			TelemetryService.instance.captureException(
-				new ApiProviderError(
-					error instanceof Error ? error.message : String(error),
-					this.providerName,
-					modelId,
-					"createMessage",
-				),
-			)
-
+			const errorMessage = error instanceof Error ? error.message : String(error)
+			const apiError = new ApiProviderError(errorMessage, this.providerName, modelId, "createMessage")
+			TelemetryService.instance.captureException(apiError)
 			throw handleOpenAIError(error, this.providerName)
 		}
 
@@ -259,23 +283,7 @@ export class OpenRouterHandler extends BaseProvider implements SingleCompletionH
 		for await (const chunk of stream) {
 			// OpenRouter returns an error object instead of the OpenAI SDK throwing an error.
 			if ("error" in chunk) {
-				const error = chunk.error as { message?: string; code?: number }
-				console.error(`OpenRouter API Error: ${error?.code} - ${error?.message}`)
-
-				TelemetryService.instance.captureException(
-					Object.assign(
-						new ApiProviderError(
-							error?.message ?? "Unknown error",
-							this.providerName,
-							modelId,
-							"createMessage",
-							error?.code,
-						),
-						{ status: error?.code },
-					),
-				)
-
-				throw new Error(`OpenRouter API Error ${error?.code}: ${error?.message}`)
+				this.handleStreamingError(chunk.error as OpenRouterErrorResponse, modelId, "createMessage")
 			}
 
 			const delta = chunk.choices[0]?.delta
@@ -473,36 +481,14 @@ export class OpenRouterHandler extends BaseProvider implements SingleCompletionH
 				signal: metadata?.signal,
 			})
 		} catch (error) {
-			TelemetryService.instance.captureException(
-				new ApiProviderError(
-					error instanceof Error ? error.message : String(error),
-					this.providerName,
-					modelId,
-					"completePrompt",
-				),
-			)
-
+			const errorMessage = error instanceof Error ? error.message : String(error)
+			const apiError = new ApiProviderError(errorMessage, this.providerName, modelId, "completePrompt")
+			TelemetryService.instance.captureException(apiError)
 			throw handleOpenAIError(error, this.providerName)
 		}
 
 		if ("error" in response) {
-			const error = response.error as { message?: string; code?: number }
-			console.error(`OpenRouter API Error: ${error?.code} - ${error?.message}`)
-
-			TelemetryService.instance.captureException(
-				Object.assign(
-					new ApiProviderError(
-						error?.message ?? "Unknown error",
-						this.providerName,
-						modelId,
-						"completePrompt",
-						error?.code,
-					),
-					{ status: error?.code },
-				),
-			)
-
-			throw new Error(`OpenRouter API Error ${error?.code}: ${error?.message}`)
+			this.handleStreamingError(response.error as OpenRouterErrorResponse, modelId, "completePrompt")
 		}
 
 		const completion = response as OpenAI.Chat.ChatCompletion