@soba-so/react 0.0.27 → 0.0.29

package/dist/ProviderMark.d.ts

@@ -0,0 +1,13 @@
+import type { JSX } from "react";
+export interface ProviderMarkProps {
+    /** `ModelProvider.mark` or `ModelOption.providerMark`: `openai`, `groq`, … */
+    provider: string;
+    className?: string;
+}
+/**
+ * THE PROVIDER'S OWN MARK, for a menu drawing `useModel().providers` — inline
+ * SVG, sized by `className`, monochrome marks in `currentColor` so they follow
+ * the text in dark mode. Nothing for a provider it has no mark for: an unknown
+ * endpoint gets no invented logo.
+ */
+export declare function ProviderMark(props: ProviderMarkProps): JSX.Element | null;

package/dist/RedeemCode.d.ts

@@ -0,0 +1,17 @@
+import { type RedeemedReward } from "./useRedeemCode.js";
+export interface RedeemCodeProps {
+    /** The button's word. "Apply" by default. */
+    label?: string;
+    /** Placeholder for the field. */
+    placeholder?: string;
+    /** Called with what the code gave, after the plan has been re-read. */
+    onRedeemed?: (reward: RedeemedReward) => void;
+    className?: string;
+}
+/**
+ * A PROMO CODE FIELD — `useRedeemCode()` with a field and a button. The code
+ * is checked by Soba: a typo, one used up, one expired or one already redeemed
+ * says so in a sentence. What it gives applies at once, and the plan state is
+ * re-read, so `<SobaCurrentPlan />` beside it moves without a reload.
+ */
+export declare function RedeemCode({ label, placeholder, onRedeemed, className, }: RedeemCodeProps): import("react").JSX.Element;

package/dist/SobaGate.d.ts

@@ -0,0 +1,35 @@
+import { type ReactNode } from "react";
+import { type FeatureView } from "./useFeature.js";
+export interface SobaGateProps {
+    /** The feature's id on the plan: `workspaces`, `export`. */
+    feature: string;
+    /** How many the gated action uses. Default 1. */
+    use?: number;
+    /** What the person may see and press. */
+    children: ReactNode;
+    /**
+     * What to show instead when they may not. A node, or a function of the
+     * answer to say something of your own. Default: Soba's card with the
+     * reason and the plans to move to.
+     */
+    fallback?: ReactNode | ((view: FeatureView) => ReactNode);
+    /** While the plan loads. Default: nothing, so no gate flashes a refusal. */
+    loading?: ReactNode;
+    className?: string;
+}
+/**
+ * SHOW IT, OR SAY WHY NOT AND OFFER THE WAY THROUGH.
+ *
+ * `<SobaGate feature="workspaces">` around a "New workspace" button draws the
+ * button while the plan allows one more, and otherwise a short card: the
+ * reason ("Your plan includes 3 workspaces, and all 3 are in use") and the
+ * plans that include more, one press away. The decision is `useFeature`'s;
+ * this only draws it, so an app with its own upgrade screen passes `fallback`
+ * or calls the hook itself.
+ *
+ * It hides a button; it does not secure an action. The server still asks
+ * `soba.users.check` before it creates anything.
+ */
+export declare function SobaGate({ feature, use, children, fallback, loading, className, }: SobaGateProps): import("react").JSX.Element;
+/** The sentence for a refusal, in the plan's own words. */
+export declare function gateMessage(view: FeatureView): string;

package/dist/context.d.ts

@@ -1,4 +1,4 @@
-import type { AgentEvent, ConnectApi, CurrentPlan, Machine, Message, Plan } from "./types.js";
+import type { AgentEvent, ConnectApi, CurrentPlan, Machine, Message, ModelLayout, ModelNameWire, ModelProviderWire, Plan } from "./types.js";
 /** What your endpoint is asked for. Everything but `signal` is forwarded to it
  *  verbatim, because the run's shape is `soba.run()`'s and yours to widen. */
 export interface RunRequest {
@@ -118,6 +118,40 @@ export interface PlanState {
     leave(): Promise<void>;
     refresh(): Promise<void>;
 }
+/**
+ * THE APP'S OWN PROVIDERS, as the gateway lists them for this person — the
+ * half of a model picker that is not their machines. Fetched the first time
+ * something reads it (`useModel` does), like `plan`.
+ */
+export interface ModelsState {
+    /** Every provider the environment and the app allow, each with its models,
+     *  locked where the person's plan does not reach it. Empty for an app with
+     *  none, and wherever the gateway has not been named. */
+    providers: ModelProviderWire[];
+    /** The app's own names for its models, set on Providers. */
+    names: ModelNameWire[];
+    /** How the app designed the picker on Connect, or null before it arrives. */
+    layout: ModelLayout | null;
+    /** Whether Fast and Best are offered; false only when the app turned them off. */
+    sizes: boolean;
+    /** Which of Automatic, Fast and Best each layout offers, when the gateway
+     *  says. See `ModelOptionsWire`. */
+    rowsByLayout: Partial<Record<ModelLayout, {
+        auto: boolean;
+        fast: boolean;
+        best: boolean;
+        own?: boolean;
+        search?: boolean;
+    }>>;
+    /** The person's ceiling as a run resolves it, or null before it arrives. */
+    route: {
+        allow: string[];
+        prefer: string[];
+    } | null;
+    loading: boolean;
+    error: Error | null;
+    refresh(): Promise<void>;
+}
 export interface SobaContextValue {
     /** The `est_` session, once there is one. */
     session: string | null;
@@ -127,6 +161,7 @@ export interface SobaContextValue {
     compute: ComputeState;
     connect: ConnectState;
     plan: PlanState;
+    models: ModelsState;
     /** Start a run through YOUR endpoint and read its events. Throws when the
      *  provider was given no `runEndpoint`, since a browser cannot start one. */
     run(request: RunRequest): Promise<AsyncIterable<AgentEvent>>;

package/dist/index.d.ts

@@ -4,27 +4,32 @@ export { ConnectCompute, type ConnectComputeProps } from "./ConnectCompute.js";
 export { ConnectModal, type ConnectModalProps } from "./ConnectModal.js";
 export { ConnectNudge, type ConnectNudgeProps } from "./ConnectNudge.js";
 export { ConnectPill, type ConnectPillProps } from "./ConnectPill.js";
-export { type ComputeState, type ConnectReason, type ConnectState, type PlanState, type RunRequest, type SobaContextValue, useSoba, } from "./context.js";
+export { type ComputeState, type ConnectReason, type ConnectState, type ModelsState, type PlanState, type RunRequest, type SobaContextValue, useSoba, } from "./context.js";
 export { collectText, parseEvent, readEvents } from "./events.js";
 export { ModelPicker, type ModelPickerProps } from "./ModelPicker.js";
+export { ProviderMark, type ProviderMarkProps } from "./ProviderMark.js";
+export { RedeemCode, type RedeemCodeProps } from "./RedeemCode.js";
 export { RunError, type RunErrorProps, runErrorMessage } from "./RunError.js";
 export { RunLimit, type RunLimitProps } from "./RunLimit.js";
 export { SobaBilling, type SobaBillingProps } from "./SobaBilling.js";
 export { SobaCheckout, type SobaCheckoutProps } from "./SobaCheckout.js";
 export { SobaCurrentPlan, type SobaCurrentPlanProps } from "./SobaCurrentPlan.js";
+export { gateMessage, SobaGate, type SobaGateProps } from "./SobaGate.js";
 export { SobaPlans, type SobaPlansProps } from "./SobaPlans.js";
 export { SobaProvider, type SobaProviderProps } from "./SobaProvider.js";
 export { injectStyles } from "./styles.js";
 export { tierLabel } from "./tier.js";
-export type { AgentEvent, AgentEventType, ConnectApi, ConnectContext, CostClass, CurrentPlan, Launch, Machine, MachineRun, MachineState, Message, ModelGroup, ModelOption, ModelOptionKind, PendingCode, Plan, Runtime, RunUsage, } from "./types.js";
+export type { AgentEvent, AgentEventType, ConnectApi, ConnectContext, CostClass, CurrentPlan, FeatureCheck, FeatureDenial, FeatureItem, Launch, Machine, MachineRun, MachineState, Message, ModelChoice, ModelGroup, ModelLayout, ModelNameWire, ModelOption, ModelOptionKind, ModelOptionsWire, ModelProviderWire, PendingCode, Plan, PlanFeatureWire, Runtime, RunUsage, } from "./types.js";
 export { type CheckoutView, type UseCheckoutOptions, useCheckout } from "./useCheckout.js";
 export { type ComputeMachine, type ComputeRuntime, type ComputeView, useCompute, } from "./useCompute.js";
 export { type ConnectButtonView, connectSays, useConnectButton } from "./useConnectButton.js";
 export { type NudgeReason, type NudgeStalled, type NudgeStep, type NudgeView, type UseConnectNudgeOptions, useConnectNudge, } from "./useConnectNudge.js";
 export { type AllowanceState, type CurrentPlanReward, type CurrentPlanView, useCurrentPlan, } from "./useCurrentPlan.js";
+export { type FeatureView, useFeature } from "./useFeature.js";
 export { type MachineRunsOptions, type MachineRunsView, useMachineRuns } from "./useMachineRuns.js";
-export { type ModelView, type UseModelOptions, useModel } from "./useModel.js";
+export { type ModelAgent, type ModelProvider, type ModelView, modelLogo, type UseModelOptions, useModel, } from "./useModel.js";
 export { useOpenSobaConnect } from "./useOpenSobaConnect.js";
 export { type PlanCompute, type PlanConnect, type PlanCta, type PlanOffer, type PlanPrice, type PlansOptions, type PlansView, usePlans, } from "./usePlans.js";
+export { type RedeemCodeView, type RedeemedReward, useRedeemCode } from "./useRedeemCode.js";
 export { type LimitReason, type Offer, sobaErrorCode, useRunLimit } from "./useRunLimit.js";
 export { type RunStream, type WatchOptions, watchRun } from "./watch.js";