ThinkPlatform-client 0.6.103__cp313-cp313-win_amd64.whl

thinkplatform/__init__.py

@@ -0,0 +1,7 @@
+# Generated binary-wheel package bootstrap; no implementation source is shipped.
+from . import _binary_init as _binary_init
+from ._binary_init import *
+
+__doc__ = _binary_init.__doc__
+if hasattr(_binary_init, "__all__"):
+    __all__ = _binary_init.__all__

thinkplatform/cli/__init__.py

@@ -0,0 +1,7 @@
+# Generated binary-wheel package bootstrap; no implementation source is shipped.
+from . import _binary_init as _binary_init
+from ._binary_init import *
+
+__doc__ = _binary_init.__doc__
+if hasattr(_binary_init, "__all__"):
+    __all__ = _binary_init.__all__

thinkplatform/cli/__main__.py

@@ -0,0 +1,5 @@
+# Generated binary-wheel module runner; no implementation source is shipped.
+from .main import main
+
+if __name__ == "__main__":
+    raise SystemExit(main())

thinkplatform/cli/agent_cost_snapshot.py

@@ -0,0 +1,23 @@
+# Generated binary-wheel module runner; no implementation source is shipped.
+from . import _binary_agent_cost_snapshot as _binary_agent_cost_snapshot
+from ._binary_agent_cost_snapshot import *
+
+for _name, _value in vars(_binary_agent_cost_snapshot).items():
+    if _name not in {"__name__", "__loader__", "__package__", "__spec__", "__file__", "__cached__", "__builtins__"}:
+        globals()[_name] = _value
+
+__doc__ = _binary_agent_cost_snapshot.__doc__
+if hasattr(_binary_agent_cost_snapshot, "__all__"):
+    __all__ = _binary_agent_cost_snapshot.__all__
+else:
+    globals().pop("__all__", None)
+
+for _value in vars(_binary_agent_cost_snapshot).values():
+    if getattr(_value, "__module__", None) == _binary_agent_cost_snapshot.__name__:
+        try:
+            _value.__module__ = __name__
+        except (AttributeError, TypeError):
+            pass
+
+if __name__ == "__main__":
+    raise SystemExit(_binary_agent_cost_snapshot.main())

thinkplatform/cli/lakehouse_cost_snapshot.py

@@ -0,0 +1,23 @@
+# Generated binary-wheel module runner; no implementation source is shipped.
+from . import _binary_lakehouse_cost_snapshot as _binary_lakehouse_cost_snapshot
+from ._binary_lakehouse_cost_snapshot import *
+
+for _name, _value in vars(_binary_lakehouse_cost_snapshot).items():
+    if _name not in {"__name__", "__loader__", "__package__", "__spec__", "__file__", "__cached__", "__builtins__"}:
+        globals()[_name] = _value
+
+__doc__ = _binary_lakehouse_cost_snapshot.__doc__
+if hasattr(_binary_lakehouse_cost_snapshot, "__all__"):
+    __all__ = _binary_lakehouse_cost_snapshot.__all__
+else:
+    globals().pop("__all__", None)
+
+for _value in vars(_binary_lakehouse_cost_snapshot).values():
+    if getattr(_value, "__module__", None) == _binary_lakehouse_cost_snapshot.__name__:
+        try:
+            _value.__module__ = __name__
+        except (AttributeError, TypeError):
+            pass
+
+if __name__ == "__main__":
+    raise SystemExit(_binary_lakehouse_cost_snapshot.main())

thinkplatform/sdk/__init__.py

@@ -0,0 +1,7 @@
+# Generated binary-wheel package bootstrap; no implementation source is shipped.
+from . import _binary_init as _binary_init
+from ._binary_init import *
+
+__doc__ = _binary_init.__doc__
+if hasattr(_binary_init, "__all__"):
+    __all__ = _binary_init.__all__

thinkplatform/sdk/execution.py

@@ -0,0 +1,23 @@
+# Generated binary-wheel module runner; no implementation source is shipped.
+from . import _binary_execution as _binary_execution
+from ._binary_execution import *
+
+for _name, _value in vars(_binary_execution).items():
+    if _name not in {"__name__", "__loader__", "__package__", "__spec__", "__file__", "__cached__", "__builtins__"}:
+        globals()[_name] = _value
+
+__doc__ = _binary_execution.__doc__
+if hasattr(_binary_execution, "__all__"):
+    __all__ = _binary_execution.__all__
+else:
+    globals().pop("__all__", None)
+
+for _value in vars(_binary_execution).values():
+    if getattr(_value, "__module__", None) == _binary_execution.__name__:
+        try:
+            _value.__module__ = __name__
+        except (AttributeError, TypeError):
+            pass
+
+if __name__ == "__main__":
+    raise SystemExit(_binary_execution.main())

thinkplatform_client-0.6.103.data/data/thinkplatform/bundled/plugins/thinkplatform/.codex-plugin/plugin.json

@@ -0,0 +1,25 @@
+{
+  "name": "thinkplatform",
+  "version": "0.1.0",
+  "description": "ThinkPlatform agent plugin with bundled skills for the tp CLI, MLOps, home pages, business apps, and remote tool workflows.",
+  "author": {
+    "name": "ThinkPlatform"
+  },
+  "skills": "./skills/",
+  "interface": {
+    "displayName": "ThinkPlatform",
+    "shortDescription": "Operate ThinkPlatform with bundled agent skills.",
+    "longDescription": "Bundled agent guidance for using the tp CLI safely from Codex, Claude-compatible skill folders, or managed ThinkPlatform workspaces.",
+    "developerName": "ThinkPlatform",
+    "category": "Productivity",
+    "capabilities": [
+      "CLI",
+      "Agent guidance"
+    ],
+    "defaultPrompt": [
+      "Use tp to inspect my ThinkPlatform context.",
+      "Use tp plugins recommend for an MLOps workflow.",
+      "Install the ThinkPlatform plugin for Codex."
+    ]
+  }
+}

thinkplatform_client-0.6.103.data/data/thinkplatform/bundled/skills/thinkplatform-agent-cost-analysis/SKILL.md

@@ -0,0 +1,70 @@
+---
+name: thinkplatform-agent-cost-analysis
+description: Use when investigating, explaining, auditing, or reporting unusually high ThinkPlatform Agent or LLM cost with the tp CLI. Trigger for requests about expensive projects, model spend, scheduled Agent runs, token or cache efficiency, prompt/context bloat, repeated Blob/PDF/OCR/tool work, runaway tasks, retries, budget risk, or cost comparisons across projects, Agents, tasks, users, models, and time windows.
+---
+
+# ThinkPlatform Agent Cost Analysis
+
+Diagnose Agent/LLM cost from provider actuals down to the ThinkPlatform configuration and execution behavior that produced it. Produce an evidence-backed Markdown report; keep the platform read-only unless the user separately authorizes changes.
+
+## Required Workflow
+
+1. Confirm the intended profile, org, project, analysis period, and report path. Read [commands](references/commands.md) before invoking `tp`.
+2. Collect a baseline snapshot with `tp-agent-cost-snapshot`. Use at least one complete billing window when available and keep dates explicit.
+3. Establish data quality before interpreting drivers:
+   - Treat provider actual cost as the financial source of truth.
+   - Report allocated, measured, and unallocated cost separately.
+   - State missing dimensions, stale provider data, and currency limitations.
+   - Read `collection_warnings` and `derived.dimension_coverage`; never infer historical model usage from current Agent settings when runtime model coverage is low.
+4. Rank cost by project, model, Agent, task, and user. Quantify concentration, daily changes, request counts, input/output/cached/reasoning tokens, and schedule run volume.
+5. Deep-dive only the highest-cost or anomalous tasks and schedules. Prefer `--summary`; retrieve raw messages only when summary evidence is insufficient and avoid reproducing sensitive content.
+6. Test each plausible mechanism using [diagnostic playbook](references/diagnostic-playbook.md). Distinguish:
+   - model price from token volume;
+   - required schedule volume from accidental fan-out, retry, or overlap;
+   - static prompt/context size from dynamic conversation growth;
+   - reusable cached prefixes from repeatedly changing prefixes;
+   - useful tool work from repeated file reads, conversion, OCR, search, or loop behavior.
+7. Check current provider pricing and billing semantics using [cost model](references/cost-model.md). Never rely on memorized or hard-coded model prices.
+8. Write the result from [report template](assets/agent-cost-analysis-report.md). Lead with quantified critical factors and confidence, then list supporting evidence, limitations, and prioritized recommendations.
+
+## Collection
+
+Run from this skill directory or pass the script's absolute path:
+
+```bash
+tp-agent-cost-snapshot \
+  --profile PROFILE \
+  --from YYYY-MM-DD \
+  --to YYYY-MM-DD \
+  --output /absolute/path/cost-snapshot.json
+```
+
+The collector is read-only. It gathers cost allocation, budgets, Agents, tasks, schedules, Hooks, skills, compact schedule logs, and compact messages for the highest-cost tasks. It infers stopped schedules and task IDs from costly `agent-cycle-*` threads, records fallback/truncation/staleness as warnings, redacts raw prompts and identity fields by default, and falls back to `tp raw get` for older CLI installations. Use `--include-raw` or `--include-dimension-series` only for a targeted follow-up.
+
+Run another snapshot for a comparison window when a model/configuration change or cost spike occurred. Compare equal-length periods where possible; do not compare raw totals across unequal durations without normalizing per day or per execution.
+
+## Analysis Rules
+
+- Attribute cost to the smallest reliable dimension, but reconcile every slice to the same provider total.
+- Use both cost share and activity share. A model can be expensive because of rate, volume, or both.
+- Calculate schedule cost as successful and attempted executions multiplied by task cost; show the unavoidable baseline separately from avoidable retry, duplication, or overlap.
+- Use cached-token data only with the provider's documented semantics. A low cache ratio is actionable only when requests share an eligible, byte-stable prefix.
+- Treat long prompts, skills, and file context as hypotheses until task evidence shows repeated input or tool work.
+- Do not label required business activity as waste. Quantify the marginal cost and identify cheaper ways to preserve the requirement.
+- Do not recommend a model downgrade without considering accuracy, latency, tool support, context limits, and retry risk.
+- Keep all recommendations read-only in the report unless the user explicitly requests implementation.
+
+## Deliverables
+
+Create:
+
+- the JSON snapshot used for analysis;
+- a Markdown report with scope, executive summary, cost reconciliation, ranked drivers, hypothesis results, critical factors, recommendations, limitations, and reproducible `tp` commands.
+
+For every major finding include the period, cost or token share, evidence source, confidence level, and a plausible alternative explanation.
+
+## Related Skills
+
+- Use `thinkplatform-agent-ops` when the user asks to change Agent prompts, models, tools, skills, memories, or team design.
+- Use `thinkplatform-automation-ops` when the user asks to change schedules, retries, Hooks, Webhooks, or follow-ups.
+- Use `thinkplatform-data-engineering` when repeated Data Lake reads or data preparation should be redesigned.

thinkplatform_client-0.6.103.data/data/thinkplatform/bundled/skills/thinkplatform-agent-cost-analysis/agents/openai.yaml

@@ -0,0 +1,4 @@
+interface:
+  display_name: "ThinkPlatform Agent Cost Analysis"
+  short_description: "Diagnose Agent and LLM cost drivers"
+  default_prompt: "Use $thinkplatform-agent-cost-analysis to audit this ThinkPlatform project Agent and LLM costs."

thinkplatform_client-0.6.103.data/data/thinkplatform/bundled/skills/thinkplatform-agent-cost-analysis/assets/agent-cost-analysis-report.md

@@ -0,0 +1,105 @@
+# ThinkPlatform Agent / LLM Cost Analysis
+
+## Scope
+
+- Profile:
+- Organization / project:
+- Analysis period:
+- Comparison period:
+- Providers / currency:
+- Snapshot:
+- Report generated:
+
+## Executive summary
+
+| Rank | Critical factor | Estimated affected share | Confidence | Why it matters |
+|---:|---|---:|---|---|
+| 1 |  |  |  |  |
+
+## Cost reconciliation
+
+| Measure | Amount | Share | Notes |
+|---|---:|---:|---|
+| Provider actual |  | 100% |  |
+| Allocated to target project |  |  |  |
+| Runtime measured |  |  |  |
+| Unallocated |  |  |  |
+
+Provider status, timestamps, currency, and coverage limitations:
+
+### Data quality
+
+| Check | Result | Analytical impact |
+|---|---|---|
+| Model cost/request coverage |  |  |
+| Agent/task coverage |  |  |
+| Provider freshness |  |  |
+| Inventory/log truncation |  |  |
+| Raw API fallback |  |  |
+
+## Trend and change points
+
+| Date/window | Cost | Requests/tasks | Tokens | Relevant configuration/event |
+|---|---:|---:|---:|---|
+|  |  |  |  |  |
+
+## Ranked drivers
+
+### Models
+
+| Model | Cost/share | Requests/share | Input/cached/output/reasoning | Interpretation |
+|---|---:|---:|---|---|
+|  |  |  |  |  |
+
+### Agents and tasks
+
+| Agent/task | Cost/share | Runs/requests | Evidence | Interpretation |
+|---|---:|---:|---|---|
+|  |  |  |  |  |
+
+### Schedules and triggers
+
+| Schedule/trigger | Intended volume | Observed volume | Retry/duplicate overhead | Cost implication |
+|---|---:|---:|---:|---|
+|  |  |  |  |  |
+
+### Prompt, context, skills, and data tools
+
+| Evidence | Observed behavior | Cost mechanism | Confidence |
+|---|---|---|---|
+|  |  |  |  |
+
+## Hypothesis assessment
+
+| Hypothesis | Result | Quantified evidence | Alternative explanation |
+|---|---|---|---|
+| Expensive model mix |  |  |  |
+| Required schedule volume |  |  |  |
+| Prompt or skill bloat |  |  |  |
+| Repeated context/file conversion |  |  |  |
+| Retry, fan-out, or Agent loop |  |  |  |
+| Attribution/measurement issue |  |  |  |
+
+## Recommendations
+
+No configuration was changed during this analysis.
+
+| Priority | Recommendation | Mechanism | Expected impact | Quality guardrail / validation |
+|---:|---|---|---|---|
+| 1 |  |  |  |  |
+
+## Limitations
+
+-
+
+## Reproduction
+
+```bash
+# Exact read-only tp commands used
+```
+
+## Pricing sources
+
+- Provider/model/tier:
+- Official URL:
+- Accessed:

thinkplatform_client-0.6.103.data/data/thinkplatform/bundled/skills/thinkplatform-agent-cost-analysis/references/commands.md

@@ -0,0 +1,130 @@
+# ThinkPlatform cost-analysis commands
+
+Use root options before the command:
+
+```bash
+tp --profile PROFILE --json COMMAND
+```
+
+When `tp` is not on `PATH`, run from `thinkplatform-lib` with `.venv/bin/tp` or pass `--tp-bin /absolute/path/to/.venv/bin/tp` to the collector. The collector auto-detects the repository `.venv/bin/tp`.
+
+All commands in this reference are read-only.
+
+## Context and profile
+
+```bash
+tp --json profile list
+tp --profile PROFILE --json profile show PROFILE
+tp --profile PROFILE --json context show
+```
+
+Confirm that `org_id` and `project_id` match the requested scope. Do not silently switch the active profile.
+
+## Cost and attribution
+
+Use explicit dates:
+
+```bash
+tp --profile PROFILE --json costs overview \
+  --from YYYY-MM-DD --to YYYY-MM-DD
+
+tp --profile PROFILE --json costs allocation \
+  --from YYYY-MM-DD --to YYYY-MM-DD --group-by project
+
+tp --profile PROFILE --json costs allocation \
+  --from YYYY-MM-DD --to YYYY-MM-DD --group-by project_model
+
+tp --profile PROFILE --json costs allocation \
+  --from YYYY-MM-DD --to YYYY-MM-DD --group-by project_agent
+
+tp --profile PROFILE --json costs allocation \
+  --from YYYY-MM-DD --to YYYY-MM-DD --group-by project_task
+
+tp --profile PROFILE --json costs allocation \
+  --from YYYY-MM-DD --to YYYY-MM-DD --group-by project_user
+
+tp --profile PROFILE --json costs budgets
+```
+
+Useful options:
+
+- `--provider openai|azure_openai|azure|all`
+- `--metric ActualCost|AmortizedCost`
+- `--force-refresh` when stale cached provider data would materially affect the result
+- `--exclude-unallocated` only for a focused view; retain unallocated cost in the reconciliation
+
+### Fallback for older CLI installations
+
+```bash
+tp --profile PROFILE --json raw get \
+  /api/organizations/ORG_ID/costs/allocation \
+  --query from=YYYY-MM-DD \
+  --query to=YYYY-MM-DD \
+  --query groupBy=project_model
+```
+
+The server must also support the requested grouping. If it does not, record the missing dimension as a limitation and use tasks, Agents, and provider breakdowns as secondary evidence.
+
+## Agent and task configuration
+
+```bash
+tp --profile PROFILE --json agents list --limit 200 --include-tools
+tp --profile PROFILE --json agents teams list
+tp --profile PROFILE --json agents models
+tp --profile PROFILE --json skills list --limit 200
+tp --profile PROFILE --json skills get SKILL_ID
+tp --profile PROFILE --json tasks list \
+  --activity-from FROM_ISO --activity-to TO_ISO --limit 200 --offset 0
+tp --profile PROFILE --json tasks list \
+  --thread-id THREAD_ID --activity-from FROM_ISO --activity-to TO_ISO
+tp --profile PROFILE --json tasks get TASK_ID
+tp --profile PROFILE --json tasks messages TASK_ID --summary
+```
+
+Only retrieve raw task messages after selecting an anomalous task:
+
+```bash
+tp --profile PROFILE --json tasks messages TASK_ID
+```
+
+Do not paste raw message content into the report. Report sizes, repetition, tool names, and short paraphrases.
+
+## Schedules and triggers
+
+```bash
+tp --profile PROFILE --json automation schedules list
+tp --profile PROFILE --json automation schedules agent-log APP_ID \
+  --from FROM_ISO --to TO_ISO --limit 500 --summary
+tp --profile PROFILE --json hooks list
+tp --profile PROFILE --json webhooks list
+tp --profile PROFILE --json tasks followups TASK_ID --include-inactive
+```
+
+Inspect:
+
+- interval/trigger and enabled status;
+- target Agent and schedule prompt;
+- run count, status mix, attempts, repeated task IDs, and errors;
+- overlapping schedules, Hooks, Webhooks, and task follow-ups that can trigger the same work.
+
+## Data-context investigation
+
+After message summaries indicate file-heavy tool use, inspect only the implicated paths:
+
+```bash
+tp --profile PROFILE --json datalake tree --path REMOTE_PATH
+tp --profile PROFILE --json datalake list --path REMOTE_PATH
+tp --profile PROFILE --json datalake preview --path REMOTE_FILE
+```
+
+Look for repeated reads of large or numerous files, raw PDFs/images requiring conversion, and missing curated indexes or summaries. Do not enumerate the entire Data Lake without evidence that it is required.
+
+## Snapshot collector
+
+```bash
+tp-agent-cost-snapshot --help
+```
+
+The default top-task and schedule summaries are bounded. Increase limits deliberately when the initial ranking shows a long tail that matters.
+
+Read `collection_warnings`, `derived.dimension_coverage`, and `derived.collection_coverage` before conclusions. Scheduler `status_counts` describe enqueue records, not downstream task outcomes; correlate them with task status.

thinkplatform_client-0.6.103.data/data/thinkplatform/bundled/skills/thinkplatform-agent-cost-analysis/references/cost-model.md

@@ -0,0 +1,87 @@
+# Provider-aware Agent cost model
+
+## Source-of-truth order
+
+Use evidence in this order:
+
+1. Provider billed/actual cost for financial totals.
+2. ThinkPlatform allocated provider actuals for project, user, Agent, task, and model attribution.
+3. Runtime measured `estimatedCost` for diagnostic detail.
+4. Token/request/duration proxies when direct cost is unavailable.
+
+Provider actuals and runtime estimates can differ because of reporting delay, currency conversion, discounts, tiers, rounding, cached-token treatment, tool charges, credits, and incomplete attribution. Reconcile the differences instead of blending them.
+
+## General formula
+
+For each provider, model, service tier, and context tier:
+
+```text
+request cost
+  = uncached input tokens × uncached input rate
+  + cached input tokens × cached input rate
+  + cache-write tokens × cache-write rate
+  + output tokens × output rate
+  + audio/image tokens × modality rates
+  + built-in tool, storage, retrieval, container, or other service charges
+```
+
+Then:
+
+```text
+period cost = sum(request cost) + fixed/provisioned capacity charges
+```
+
+Do not assume all providers expose every component or that cached tokens are separate from total input tokens. Confirm field semantics before subtracting or adding token categories.
+
+## Metrics to calculate
+
+- Cost share: `slice actual cost / project actual cost`.
+- Activity share: `slice requests / project requests`.
+- Effective cost per request: `slice actual cost / slice requests`.
+- Effective cost per million input/output tokens: use only when token coverage is adequate and label it as blended.
+- Cache ratio: `cached input tokens / input tokens` only when input tokens include cached tokens.
+- Output amplification: `output tokens / input tokens`.
+- Reasoning share: `reasoning tokens / output tokens` only when the provider documents reasoning as part of output.
+- Daily execution rate: `requests or tasks / active days`.
+- Schedule overhead: failed, retried, duplicated, or overlapping executions × representative task cost.
+- Concentration: cost share of top model, Agent, task, user, and day.
+
+Always handle zero denominators and disclose low token coverage.
+
+## Current pricing verification
+
+Pricing is time-sensitive. At analysis time, verify the specific provider, model snapshot, region, service tier, and context length using official sources:
+
+- OpenAI API pricing: <https://developers.openai.com/api/docs/pricing>
+- OpenAI prompt caching: <https://developers.openai.com/api/docs/guides/prompt-caching>
+- OpenAI Batch API: <https://developers.openai.com/api/docs/guides/batch>
+- OpenAI Usage API: <https://platform.openai.com/docs/api-reference/usage>
+- Azure OpenAI pricing: <https://azure.microsoft.com/pricing/details/cognitive-services/openai-service/>
+- Azure OpenAI prompt caching: <https://learn.microsoft.com/azure/ai-services/openai/how-to/prompt-caching>
+- Azure provisioned throughput billing: <https://learn.microsoft.com/azure/foundry/openai/concepts/provisioned-throughput-billing>
+
+Record the URL and access date in the report. Do not copy a price from this skill.
+
+## Pricing distinctions that change conclusions
+
+- Input, cached input, cache writes, and output can have different rates.
+- Long-context tiers can change rates above provider-specific thresholds.
+- Standard, Batch, Flex, priority/fast, and provisioned capacity have different economics.
+- Some built-in tools and storage are billed separately from model tokens.
+- Azure Standard token billing and provisioned throughput unit/hour billing require different utilization analyses.
+- A cheaper model that increases retries, output, or tool loops can cost more per successful outcome.
+
+## Prompt caching interpretation
+
+Caching helps only when requests are eligible and share an exact stable prefix under the provider's rules. Place stable instructions and common context before variable user/task content when platform behavior permits.
+
+Do not call low cache usage waste when:
+
+- requests are below the provider's cache eligibility threshold;
+- prompts legitimately differ at the beginning;
+- traffic is too sparse or separated beyond cache lifetime;
+- the provider/model/tier does not support the expected cache behavior.
+
+## Currency and billing period
+
+Keep provider currencies separate unless ThinkPlatform supplies a documented conversion. State the exchange-rate source and date when converting. Align analysis dates with provider reporting timezone and note that very recent days may be incomplete.