FilesExpand file tree

main

/

pi-providers.ts

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

80 lines (69 loc) · 3.5 KB

main

/

pi-providers.ts

Copy path

Top

File metadata and controls

• Code
• Blame

80 lines (69 loc) · 3.5 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

import { PI_MODEL_IDS_BY_PROVIDER } from '@/providers/pi-model-catalog.generated'

import {

PI_PROVIDER_CONFIGS,

type PiProviderConfig,

type PiSupportedProvider,

} from '@/providers/pi-provider-configs'

import type { BYOKProviderId } from '@/tools/types'

const PI_PROVIDER_CONFIG_BY_ID = new Map<string, PiProviderConfig>(

PI_PROVIDER_CONFIGS.map((config) => [config.id, config])

)

const PI_MODEL_IDS_BY_PROVIDER_ID = new Map<PiSupportedProvider, ReadonlySet<string>>(

PI_PROVIDER_CONFIGS.map(({ id }) => [id, new Set(PI_MODEL_IDS_BY_PROVIDER[id])])

)

/** Whether Sim can run the provider through Pi's single-key flow. */

export function isPiSupportedProvider(providerId: string): providerId is PiSupportedProvider {

return PI_PROVIDER_CONFIG_BY_ID.has(providerId)

}

/**

* Whether a Pi block mode hands the model API key into the sandbox and

* therefore always requires the user's own key. Create PR (`cloud`), Update PR

* (`cloud_branch`), and Plan (`cloud_plan`) run the model client inside the

* sandbox, so Sim never supplies a hosted key for them: the block always shows the API Key field,

* copilot validation never strips it, and execution requires BYOK. Review Code

* and Local Dev keep the model client in Sim and follow the normal hosted-key

* rules. All three enforcement sites (block condition, edit-workflow

* validation, key resolution) consume this predicate so they cannot drift.

*/

export function isPiByokOnlyMode(mode: unknown): boolean {

return mode === 'cloud' || mode === 'cloud_branch' || mode === 'cloud_plan'

}

/** Returns Pi's provider ID for a supported Sim provider. */

export function getPiProviderId(providerId: PiSupportedProvider): PiProviderConfig['piProviderId'] {

const config = PI_PROVIDER_CONFIG_BY_ID.get(providerId)

if (!config) throw new Error(`Pi provider configuration is missing for "${providerId}"`)

return config.piProviderId

}

/** Returns the environment variable consumed by Pi's CLI for a supported provider. */

export function getPiProviderApiKeyEnvVar(

providerId: PiSupportedProvider

): PiProviderConfig['apiKeyEnvVar'] {

const config = PI_PROVIDER_CONFIG_BY_ID.get(providerId)

if (!config) throw new Error(`Pi provider configuration is missing for "${providerId}"`)

return config.apiKeyEnvVar

}

/** Returns the stored workspace-key provider supported by this Pi provider. */

export function getPiWorkspaceBYOKProviderId(

providerId: PiSupportedProvider

): BYOKProviderId | undefined {

return PI_PROVIDER_CONFIG_BY_ID.get(providerId)?.workspaceBYOKProviderId

}

/**

* Resolves a Sim model ID to the exact provider-relative ID in Pi's pinned

* catalog. Sim prefixes model IDs for providers whose native IDs overlap; Pi

* sometimes keeps that prefix (NVIDIA) and sometimes does not (Groq), so exact

* IDs are checked before removing the Sim provider prefix.

*/

export function resolvePiModelId(providerId: string, modelId: string): string | undefined {

if (!isPiSupportedProvider(providerId)) return undefined

const modelIds = PI_MODEL_IDS_BY_PROVIDER_ID.get(providerId)

if (modelIds?.has(modelId)) return modelId

const providerPrefix = `${providerId}/`

if (!modelId.startsWith(providerPrefix)) return undefined

const providerRelativeId = modelId.slice(providerPrefix.length)

return modelIds?.has(providerRelativeId) ? providerRelativeId : undefined

}

/** Whether the provider/model pair exists in Pi's pinned catalog. */

export function isPiSupportedModel(providerId: string, modelId: string): boolean {

return resolvePiModelId(providerId, modelId) !== undefined

}